FVG LevelsFVG Levels Indicator Description
The FVG Levels indicator dynamically identifies and displays key price zones that may represent fair value gaps and order block areas, helping traders to visually pinpoint potential support and resistance levels directly on the chart.
Key Features
Order Block Identification:
The indicator detects bullish and bearish order blocks by analyzing specific candle patterns. For bullish zones, it checks if a candle two bars ago was bullish (close greater than open) coupled with a subsequent gap condition. Similarly, bearish zones are identified when bearish candle conditions are met with an appropriate gap.
Dynamic Zone Calculation:
It computes critical levels such as the highest highs, lowest lows, highest lows, and lowest highs over a series of recent bars. These levels define the boundaries of potential buy and sell zones and adjust dynamically as new price data comes in.
Visual Representation:
Buy zones are plotted in lime and sell zones in yellow, with the indicator filling the areas between the high and low lines to create clear, shaded bands. This visual aid helps in quickly recognizing zones of potential price reaction.
Chart Overlay:
Designed to work as an overlay, the indicator integrates directly onto your price chart, allowing for seamless correlation between price action and identified zones.
How It Works
Bullish Zones:
When a bullish candle (with the candle's close above its open) is detected along with a significant gap, the indicator marks the upper and lower boundaries of the bullish order block. It further refines these levels by tracking the lowest low and highest high over recent bars to enhance the zone's definition.
Bearish Zones:
In a similar manner, the indicator calculates bearish order blocks by confirming bearish candle conditions and corresponding gap criteria. It then updates the bearish zone levels and computes the highest high and lowest low to establish clear sell zone boundaries.
Usage
Traders can use the FVG Levels indicator to:
Identify potential entry and exit points by observing where price may reverse or consolidate.
Recognize fair value gaps or imbalances that often act as magnet points for price action.
Enhance risk management by using the dynamically calculated zones to set stop-losses or take-profits.
"order block" için komut dosyalarını ara
lib_smcLibrary "lib_smc"
This is an adaptation of LuxAlgo's Smart Money Concepts indicator with numerous changes. Main changes include integration of object based plotting, plenty of performance improvements, live tracking of Order Blocks, integration of volume profiles to refine Order Blocks, and many more.
This is a library for developers, if you want this converted into a working strategy, let me know.
buffer(item, len, force_rotate)
Parameters:
item (float)
len (int)
force_rotate (bool)
buffer(item, len, force_rotate)
Parameters:
item (int)
len (int)
force_rotate (bool)
buffer(item, len, force_rotate)
Parameters:
item (Profile type from robbatt/lib_profile/32)
len (int)
force_rotate (bool)
swings(len)
INTERNAL: detect swing points (HH and LL) in given range
Parameters:
len (simple int) : range to check for new swing points
Returns: values are the price level where and if a new HH or LL was detected, else na
method init(this)
Namespace types: OrderBlockConfig
Parameters:
this (OrderBlockConfig)
method delete(this)
Namespace types: OrderBlock
Parameters:
this (OrderBlock)
method clear_broken(this, broken_buffer)
INTERNAL: delete internal order blocks box coordinates if top/bottom is broken
Namespace types: map
Parameters:
this (map)
broken_buffer (map)
Returns: any_bull_ob_broken, any_bear_ob_broken, broken signals are true if an according order block was broken/mitigated, broken contains the broken block(s)
create_ob(id, mode, start_t, start_i, top, end_t, end_i, bottom, break_price, early_confirmation_price, config, init_plot, force_overlay)
INTERNAL: set internal order block coordinates
Parameters:
id (int)
mode (int) : 1: bullish, -1 bearish block
start_t (int)
start_i (int)
top (float)
end_t (int)
end_i (int)
bottom (float)
break_price (float)
early_confirmation_price (float)
config (OrderBlockConfig)
init_plot (bool)
force_overlay (bool)
Returns: signals are true if an according order block was broken/mitigated
method align_to_profile(block, align_edge, align_break_price)
Namespace types: OrderBlock
Parameters:
block (OrderBlock)
align_edge (bool)
align_break_price (bool)
method create_profile(block, opens, tops, bottoms, closes, values, resolution, vah_pc, val_pc, args, init_calculated, init_plot, force_overlay)
Namespace types: OrderBlock
Parameters:
block (OrderBlock)
opens (array)
tops (array)
bottoms (array)
closes (array)
values (array)
resolution (int)
vah_pc (float)
val_pc (float)
args (ProfileArgs type from robbatt/lib_profile/32)
init_calculated (bool)
init_plot (bool)
force_overlay (bool)
method create_profile(block, resolution, vah_pc, val_pc, args, init_calculated, init_plot, force_overlay)
Namespace types: OrderBlock
Parameters:
block (OrderBlock)
resolution (int)
vah_pc (float)
val_pc (float)
args (ProfileArgs type from robbatt/lib_profile/32)
init_calculated (bool)
init_plot (bool)
force_overlay (bool)
track_obs(swing_len, hh, ll, top, btm, bull_bos_alert, bull_choch_alert, bear_bos_alert, bear_choch_alert, min_block_size, max_block_size, config_bull, config_bear, init_plot, force_overlay, enabled, extend_blocks, clear_broken_buffer_before, align_edge_to_value_area, align_break_price_to_poc, profile_args_bull, profile_args_bear, use_soft_confirm, soft_confirm_offset, use_retracements_with_FVG_out)
Parameters:
swing_len (int)
hh (float)
ll (float)
top (float)
btm (float)
bull_bos_alert (bool)
bull_choch_alert (bool)
bear_bos_alert (bool)
bear_choch_alert (bool)
min_block_size (float)
max_block_size (float)
config_bull (OrderBlockConfig)
config_bear (OrderBlockConfig)
init_plot (bool)
force_overlay (bool)
enabled (bool)
extend_blocks (simple bool)
clear_broken_buffer_before (simple bool)
align_edge_to_value_area (simple bool)
align_break_price_to_poc (simple bool)
profile_args_bull (ProfileArgs type from robbatt/lib_profile/32)
profile_args_bear (ProfileArgs type from robbatt/lib_profile/32)
use_soft_confirm (simple bool)
soft_confirm_offset (float)
use_retracements_with_FVG_out (simple bool)
method draw(this, config, extend_only)
Namespace types: OrderBlock
Parameters:
this (OrderBlock)
config (OrderBlockConfig)
extend_only (bool)
method draw(blocks, config)
INTERNAL: plot order blocks
Namespace types: array
Parameters:
blocks (array)
config (OrderBlockConfig)
method draw(blocks, config)
INTERNAL: plot order blocks
Namespace types: map
Parameters:
blocks (map)
config (OrderBlockConfig)
method cleanup(this, ob_bull, ob_bear)
removes all Profiles that are older than the latest OrderBlock from this profile buffer
Namespace types: array
Parameters:
this (array type from robbatt/lib_profile/32)
ob_bull (OrderBlock)
ob_bear (OrderBlock)
_plot_swing_points(mode, x, y, show_swing_points, linecolor_swings, keep_history, show_latest_swings_levels, trail_x, trail_y, trend)
INTERNAL: plot swing points
Parameters:
mode (int) : 1: bullish, -1 bearish block
x (int) : x-coordingate of swing point to plot (bar_index)
y (float) : y-coordingate of swing point to plot (price)
show_swing_points (bool) : switch to enable/disable plotting of swing point labels
linecolor_swings (color) : color for swing point labels and lates level lines
keep_history (bool) : weater to remove older swing point labels and only keep the most recent
show_latest_swings_levels (bool)
trail_x (int) : x-coordinate for latest swing point (bar_index)
trail_y (float) : y-coordinate for latest swing point (price)
trend (int) : the current trend 1: bullish, -1: bearish, to determine Strong/Weak Low/Highs
_pivot_lvl(mode, trend, hhll_x, hhll, super_hhll, filter_insignificant_internal_breaks)
INTERNAL: detect whether a structural level has been broken and if it was in trend direction (BoS) or against trend direction (ChoCh), also track the latest high and low swing points
Parameters:
mode (simple int) : detect 1: bullish, -1 bearish pivot points
trend (int) : current trend direction
hhll_x (int) : x-coordinate of newly detected hh/ll (bar_index)
hhll (float) : y-coordinate of newly detected hh/ll (price)
super_hhll (float) : level/y-coordinate of superior hhll (if this is an internal structure pivot level)
filter_insignificant_internal_breaks (bool) : if true pivot points / internal structure will be ignored where the wick in trend direction is longer than the opposite (likely to push further in direction of main trend)
Returns: coordinates of internal structure that has been broken (x,y): start of structure, (trail_x, trail_y): tracking hh/ll after structure break, (bos_alert, choch_alert): signal whether a structural level has been broken
_plot_structure(x, y, is_bos, is_choch, line_color, line_style, label_style, label_size, keep_history)
INTERNAL: plot structural breaks (BoS/ChoCh)
Parameters:
x (int) : x-coordinate of newly broken structure (bar_index)
y (float) : y-coordinate of newly broken structure (price)
is_bos (bool) : whether this structural break was in trend direction
is_choch (bool) : whether this structural break was against trend direction
line_color (color) : color for the line connecting the structural level and the breaking candle
line_style (string) : style (line.style_dashed/solid) for the line connecting the structural level and the breaking candle
label_style (string) : style (label.style_label_down/up) for the label above/below the line connecting the structural level and the breaking candle
label_size (string) : size (size.small/tiny) for the label above/below the line connecting the structural level and the breaking candle
keep_history (bool) : weater to remove older swing point labels and only keep the most recent
structure_values(length, super_hh, super_ll, filter_insignificant_internal_breaks)
detect (and plot) structural breaks and the resulting new trend
Parameters:
length (simple int) : lookback period for swing point detection
super_hh (float) : level/y-coordinate of superior hh (for internal structure detection)
super_ll (float) : level/y-coordinate of superior ll (for internal structure detection)
filter_insignificant_internal_breaks (bool) : if true pivot points / internal structure will be ignored where the wick in trend direction is longer than the opposite (likely to push further in direction of main trend)
Returns: trend: direction 1:bullish -1:bearish, (bull_bos_alert, bull_choch_alert, top_x, top_y, trail_up_x, trail_up): whether and which level broke in a bullish direction, trailing high, (bbear_bos_alert, bear_choch_alert, tm_x, btm_y, trail_dn_x, trail_dn): same in bearish direction
structure_plot(trend, bull_bos_alert, bull_choch_alert, top_x, top_y, trail_up_x, trail_up, hh, bear_bos_alert, bear_choch_alert, btm_x, btm_y, trail_dn_x, trail_dn, ll, color_bull, color_bear, show_swing_points, show_latest_swings_levels, show_bos, show_choch, line_style, label_size, keep_history)
detect (and plot) structural breaks and the resulting new trend
Parameters:
trend (int) : crrent trend 1: bullish, -1: bearish
bull_bos_alert (bool) : if there was a bullish bos alert -> plot it
bull_choch_alert (bool) : if there was a bullish choch alert -> plot it
top_x (int) : latest shwing high x
top_y (float) : latest swing high y
trail_up_x (int) : trailing high x
trail_up (float) : trailing high y
hh (float) : if there was a higher high
bear_bos_alert (bool) : if there was a bearish bos alert -> plot it
bear_choch_alert (bool) : if there was a bearish chock alert -> plot it
btm_x (int) : latest swing low x
btm_y (float) : latest swing low y
trail_dn_x (int) : trailing low x
trail_dn (float) : trailing low y
ll (float) : if there was a lower low
color_bull (color) : color for bullish BoS/ChoCh levels
color_bear (color) : color for bearish BoS/ChoCh levels
show_swing_points (bool) : whether to plot swing point labels
show_latest_swings_levels (bool) : whether to track and plot latest swing point levels with lines
show_bos (bool) : whether to plot BoS levels
show_choch (bool) : whether to plot ChoCh levels
line_style (string) : whether to plot BoS levels
label_size (string) : label size of plotted BoS/ChoCh levels
keep_history (bool) : weater to remove older swing point labels and only keep the most recent
structure(length, color_bull, color_bear, super_hh, super_ll, filter_insignificant_internal_breaks, show_swing_points, show_latest_swings_levels, show_bos, show_choch, line_style, label_size, keep_history, enabled)
detect (and plot) structural breaks and the resulting new trend
Parameters:
length (simple int) : lookback period for swing point detection
color_bull (color) : color for bullish BoS/ChoCh levels
color_bear (color) : color for bearish BoS/ChoCh levels
super_hh (float) : level/y-coordinate of superior hh (for internal structure detection)
super_ll (float) : level/y-coordinate of superior ll (for internal structure detection)
filter_insignificant_internal_breaks (bool) : if true pivot points / internal structure will be ignored where the wick in trend direction is longer than the opposite (likely to push further in direction of main trend)
show_swing_points (bool) : whether to plot swing point labels
show_latest_swings_levels (bool) : whether to track and plot latest swing point levels with lines
show_bos (bool) : whether to plot BoS levels
show_choch (bool) : whether to plot ChoCh levels
line_style (string) : whether to plot BoS levels
label_size (string) : label size of plotted BoS/ChoCh levels
keep_history (bool) : weater to remove older swing point labels and only keep the most recent
enabled (bool)
_check_equal_level(mode, len, eq_threshold, enabled)
INTERNAL: detect equal levels (double top/bottom)
Parameters:
mode (int) : detect 1: bullish/high, -1 bearish/low pivot points
len (int) : lookback period for equal level (swing point) detection
eq_threshold (float) : maximum price offset for a level to be considered equal
enabled (bool)
Returns: eq_alert whether an equal level was detected and coordinates of the first and the second level/swing point
_plot_equal_level(show_eq, x1, y1, x2, y2, label_txt, label_style, label_size, line_color, line_style, keep_history)
INTERNAL: plot equal levels (double top/bottom)
Parameters:
show_eq (bool) : whether to plot the level or not
x1 (int) : x-coordinate of the first level / swing point
y1 (float) : y-coordinate of the first level / swing point
x2 (int) : x-coordinate of the second level / swing point
y2 (float) : y-coordinate of the second level / swing point
label_txt (string) : text for the label above/below the line connecting the equal levels
label_style (string) : style (label.style_label_down/up) for the label above/below the line connecting the equal levels
label_size (string) : size (size.tiny) for the label above/below the line connecting the equal levels
line_color (color) : color for the line connecting the equal levels (and it's label)
line_style (string) : style (line.style_dotted) for the line connecting the equal levels
keep_history (bool) : weater to remove older swing point labels and only keep the most recent
equal_levels_values(len, threshold, enabled)
detect (and plot) equal levels (double top/bottom), returns coordinates
Parameters:
len (int) : lookback period for equal level (swing point) detection
threshold (float) : maximum price offset for a level to be considered equal
enabled (bool) : whether detection is enabled
Returns: (eqh_alert, eqh_x1, eqh_y1, eqh_x2, eqh_y2) whether an equal high was detected and coordinates of the first and the second level/swing point, (eql_alert, eql_x1, eql_y1, eql_x2, eql_y2) same for equal lows
equal_levels_plot(eqh_x1, eqh_y1, eqh_x2, eqh_y2, eql_x1, eql_y1, eql_x2, eql_y2, color_eqh, color_eql, show, keep_history)
detect (and plot) equal levels (double top/bottom), returns coordinates
Parameters:
eqh_x1 (int) : coordinates of first point of equal high
eqh_y1 (float) : coordinates of first point of equal high
eqh_x2 (int) : coordinates of second point of equal high
eqh_y2 (float) : coordinates of second point of equal high
eql_x1 (int) : coordinates of first point of equal low
eql_y1 (float) : coordinates of first point of equal low
eql_x2 (int) : coordinates of second point of equal low
eql_y2 (float) : coordinates of second point of equal low
color_eqh (color) : color for the line connecting the equal highs (and it's label)
color_eql (color) : color for the line connecting the equal lows (and it's label)
show (bool) : whether plotting is enabled
keep_history (bool) : weater to remove older swing point labels and only keep the most recent
Returns: (eqh_alert, eqh_x1, eqh_y1, eqh_x2, eqh_y2) whether an equal high was detected and coordinates of the first and the second level/swing point, (eql_alert, eql_x1, eql_y1, eql_x2, eql_y2) same for equal lows
equal_levels(len, threshold, color_eqh, color_eql, enabled, show, keep_history)
detect (and plot) equal levels (double top/bottom)
Parameters:
len (int) : lookback period for equal level (swing point) detection
threshold (float) : maximum price offset for a level to be considered equal
color_eqh (color) : color for the line connecting the equal highs (and it's label)
color_eql (color) : color for the line connecting the equal lows (and it's label)
enabled (bool) : whether detection is enabled
show (bool) : whether plotting is enabled
keep_history (bool) : weater to remove older swing point labels and only keep the most recent
Returns: (eqh_alert) whether an equal high was detected, (eql_alert) same for equal lows
_detect_fvg(mode, enabled, o, h, l, c, filter_insignificant_fvgs, change_tf)
INTERNAL: detect FVG (fair value gap)
Parameters:
mode (int) : detect 1: bullish, -1 bearish gaps
enabled (bool) : whether detection is enabled
o (float) : reference source open
h (float) : reference source high
l (float) : reference source low
c (float) : reference source close
filter_insignificant_fvgs (bool) : whether to calculate and filter small/insignificant gaps
change_tf (bool) : signal when the previous reference timeframe closed, triggers new calculation
Returns: whether a new FVG was detected and its top/mid/bottom levels
_clear_broken_fvg(mode, upper_boxes, lower_boxes)
INTERNAL: clear mitigated FVGs (fair value gaps)
Parameters:
mode (int) : detect 1: bullish, -1 bearish gaps
upper_boxes (array) : array that stores the upper parts of the FVG boxes
lower_boxes (array) : array that stores the lower parts of the FVG boxes
_plot_fvg(mode, show, top, mid, btm, border_color, extend_box)
INTERNAL: plot (and clear broken) FVG (fair value gap)
Parameters:
mode (int) : plot 1: bullish, -1 bearish gap
show (bool) : whether plotting is enabled
top (float) : top level of fvg
mid (float) : center level of fvg
btm (float) : bottom level of fvg
border_color (color) : color for the FVG box
extend_box (int) : how many bars into the future the FVG box should be extended after detection
fvgs_values(o, h, l, c, filter_insignificant_fvgs, change_tf, enabled)
detect (and plot / clear broken) FVGs (fair value gaps), and return alerts and level values
Parameters:
o (float) : reference source open
h (float) : reference source high
l (float) : reference source low
c (float) : reference source close
filter_insignificant_fvgs (bool) : whether to calculate and filter small/insignificant gaps
change_tf (bool) : signal when the previous reference timeframe closed, triggers new calculation
enabled (bool) : whether detection is enabled
Returns: (bullish_fvg_alert, bull_top, bull_mid, bull_btm): whether a new bullish FVG was detected and its top/mid/bottom levels, (bearish_fvg_alert, bear_top, bear_mid, bear_btm): same for bearish FVGs
fvgs_plot(bullish_fvg_alert, bull_top, bull_mid, bull_btm, bearish_fvg_alert, bear_top, bear_mid, bear_btm, color_bull, color_bear, extend_box, show)
Parameters:
bullish_fvg_alert (bool)
bull_top (float)
bull_mid (float)
bull_btm (float)
bearish_fvg_alert (bool)
bear_top (float)
bear_mid (float)
bear_btm (float)
color_bull (color) : color for bullish FVG boxes
color_bear (color) : color for bearish FVG boxes
extend_box (int) : how many bars into the future the FVG box should be extended after detection
show (bool) : whether plotting is enabled
Returns: (bullish_fvg_alert, bull_top, bull_mid, bull_btm): whether a new bullish FVG was detected and its top/mid/bottom levels, (bearish_fvg_alert, bear_top, bear_mid, bear_btm): same for bearish FVGs
fvgs(o, h, l, c, filter_insignificant_fvgs, change_tf, color_bull, color_bear, extend_box, enabled, show)
detect (and plot / clear broken) FVGs (fair value gaps)
Parameters:
o (float) : reference source open
h (float) : reference source high
l (float) : reference source low
c (float) : reference source close
filter_insignificant_fvgs (bool) : whether to calculate and filter small/insignificant gaps
change_tf (bool) : signal when the previous reference timeframe closed, triggers new calculation
color_bull (color) : color for bullish FVG boxes
color_bear (color) : color for bearish FVG boxes
extend_box (int) : how many bars into the future the FVG box should be extended after detection
enabled (bool) : whether detection is enabled
show (bool) : whether plotting is enabled
Returns: (bullish_fvg_alert): whether a new bullish FVG was detected, (bearish_fvg_alert): same for bearish FVGs
OrderBlock
Fields:
id (series int)
dir (series int)
left_top (chart.point)
right_bottom (chart.point)
break_price (series float)
early_confirmation_price (series float)
ltf_high (array)
ltf_low (array)
ltf_volume (array)
plot (Box type from robbatt/lib_plot_objects/49)
profile (Profile type from robbatt/lib_profile/32)
trailing (series bool)
extending (series bool)
awaiting_confirmation (series bool)
touched_break_price_before_confirmation (series bool)
soft_confirmed (series bool)
has_fvg_out (series bool)
hidden (series bool)
broken (series bool)
OrderBlockConfig
Fields:
show (series bool)
show_last (series int)
show_id (series bool)
show_profile (series bool)
args (BoxArgs type from robbatt/lib_plot_objects/49)
txt (series string)
txt_args (BoxTextArgs type from robbatt/lib_plot_objects/49)
delete_when_broken (series bool)
broken_args (BoxArgs type from robbatt/lib_plot_objects/49)
broken_txt (series string)
broken_txt_args (BoxTextArgs type from robbatt/lib_plot_objects/49)
broken_profile_args (ProfileArgs type from robbatt/lib_profile/32)
use_profile (series bool)
profile_args (ProfileArgs type from robbatt/lib_profile/32)
OrderBlock [kyleAlgo]The principle of this indicator
ATR (Average True Range) Setting: The code uses ATR to help calculate the Supertrend indicator.
Supertrend Trend Direction: Identify bullish and bearish trends with the Supertrend method.
Order Block Recognition: This part of the code recognizes and creates order blocks, visualizing them as boxes on the chart. If the number of blocks exceeds the maximum limit, old blocks will be deleted.
Function to prevent overlapping: check whether the new order block overlaps with the existing order block through the isOverlapping function.
Order block color setting: The code sets the color according to whether the block is bullish or bearish, and whether it breaks above or below. Afterwards the color of the existing order blocks will be updated.
Sensitivity settings: Through the input settings of factor and atrPeriod, the sensitivity of Supertrend and the detection of order blocks can be affected.
Visualization: Use TradingView's box.new function to draw and visualize order blocks on the chart.
Practicality:
Support and Resistance Levels: Order blocks may represent areas of support and resistance in the market. By visualizing these areas, traders can better understand when price reversals are likely to occur.
Trading Signals: Traders may be able to identify trading signals based on the color changes of blocks and price breakouts. For example, if the price breaks above a bullish block, this could be a signal to buy.
Risk Management: By using ATR to adjust the sensitivity of Supertrend, the symbol helps traders to adjust their strategies according to market volatility. This can be used as a risk management tool to help identify stop loss and take profit points.
Multi-timeframe analysis: Although the code itself does not implement multi-timeframe analysis directly, it can be done by applying this indicator on different timeframes. This helps to analyze the market from different angles.
Flexibility and Customization: Through sensitivity settings, traders can customize the indicator according to their needs and trading style.
Reduced screen clutter: By removing overlapping order blocks and limiting the maximum number of order blocks, this code helps reduce clutter on charts, allowing traders to analyze the market more clearly.
Overall, this "Pine Script" can be a powerful analytical tool for trend traders and those looking to improve their trading decisions by visualizing key market areas. It can be used alone or combined with other indicators and trading systems for enhanced functionality.
Guardeer//@version=5
indicator("Guardeer", shorttitle = "Guardeer", overlay = true, max_lines_count = 500, max_labels_count = 500, max_boxes_count = 500, max_bars_back = 500, max_polylines_count = 100)
//-----------------------------------------------------------------------------{
//Boolean set
//-----------------------------------------------------------------------------{
s_BOS = 0
s_CHoCH = 1
i_BOS = 2
i_CHoCH = 3
i_pp_CHoCH = 4
green_candle = 5
red_candle = 6
s_CHoCHP = 7
i_CHoCHP = 8
boolean =
array.from(
false
, false
, false
, false
, false
, false
, false
, false
, false
)
//-----------------------------------------------------------------------------{
// User inputs
//-----------------------------------------------------------------------------{
show_swing_ms = input.string ("All" , "Swing " , inline = "1", group = "MARKET STRUCTURE" , options = )
show_internal_ms = input.string ("All" , "Internal " , inline = "2", group = "MARKET STRUCTURE" , options = )
internal_r_lookback = input.int (5 , "" , inline = "2", group = "MARKET STRUCTURE" , minval = 2)
swing_r_lookback = input.int (50 , "" , inline = "1", group = "MARKET STRUCTURE" , minval = 2)
ms_mode = input.string ("Manual" , "Market Structure Mode" , inline = "a", group = "MARKET STRUCTURE" , tooltip = " Use selected lenght\n Use automatic lenght" ,options = )
show_mtf_str = input.bool (true , "MTF Scanner" , inline = "9", group = "MARKET STRUCTURE" , tooltip = "Display Multi-Timeframe Market Structure Trend Directions. Green = Bullish. Red = Bearish")
show_eql = input.bool (false , "Show EQH/EQL" , inline = "6", group = "MARKET STRUCTURE")
plotcandle_bool = input.bool (false , "Plotcandle" , inline = "3", group = "MARKET STRUCTURE" , tooltip = "Displays a cleaner colored candlestick chart in place of the default candles. (requires hiding the current ticker candles)")
barcolor_bool = input.bool (false , "Bar Color" , inline = "4", group = "MARKET STRUCTURE" , tooltip = "Color the candle bodies according to market strucutre trend")
i_ms_up_BOS = input.color (#089981 , "" , inline = "2", group = "MARKET STRUCTURE")
i_ms_dn_BOS = input.color (#f23645 , "" , inline = "2", group = "MARKET STRUCTURE")
s_ms_up_BOS = input.color (#089981 , "" , inline = "1", group = "MARKET STRUCTURE")
s_ms_dn_BOS = input.color (#f23645 , "" , inline = "1", group = "MARKET STRUCTURE")
lvl_daily = input.bool (false , "Day " , inline = "1", group = "HIGHS & LOWS MTF")
lvl_weekly = input.bool (false , "Week " , inline = "2", group = "HIGHS & LOWS MTF")
lvl_monthly = input.bool (false , "Month" , inline = "3", group = "HIGHS & LOWS MTF")
lvl_yearly = input.bool (false , "Year " , inline = "4", group = "HIGHS & LOWS MTF")
css_d = input.color (color.blue , "" , inline = "1", group = "HIGHS & LOWS MTF")
css_w = input.color (color.blue , "" , inline = "2", group = "HIGHS & LOWS MTF")
css_m = input.color (color.blue , "" , inline = "3", group = "HIGHS & LOWS MTF")
css_y = input.color (color.blue , "" , inline = "4", group = "HIGHS & LOWS MTF")
s_d = input.string ('⎯⎯⎯' , '' , inline = '1', group = 'HIGHS & LOWS MTF' , options = )
s_w = input.string ('⎯⎯⎯' , '' , inline = '2', group = 'HIGHS & LOWS MTF' , options = )
s_m = input.string ('⎯⎯⎯' , '' , inline = '3', group = 'HIGHS & LOWS MTF' , options = )
s_y = input.string ('⎯⎯⎯' , '' , inline = '4', group = 'HIGHS & LOWS MTF' , options = )
ob_show = input.bool (true , "Show Last " , inline = "1", group = "VOLUMETRIC ORDER BLOCKS" , tooltip = "Display volumetric order blocks on the chart \n\n Ammount of volumetric order blocks to show")
ob_num = input.int (5 , "" , inline = "1", group = "VOLUMETRIC ORDER BLOCKS" , tooltip = "Orderblocks number", minval = 1, maxval = 10)
ob_metrics_show = input.bool (true , "Internal Buy/Sell Activity" , inline = "2", group = "VOLUMETRIC ORDER BLOCKS" , tooltip = "Display volume metrics that have formed the orderblock")
css_metric_up = input.color (color.new(#089981, 50) , " " , inline = "2", group = "VOLUMETRIC ORDER BLOCKS")
css_metric_dn = input.color (color.new(#f23645 , 50) , "" , inline = "2", group = "VOLUMETRIC ORDER BLOCKS")
ob_swings = input.bool (false , "Swing Order Blocks" , inline = "a", group = "VOLUMETRIC ORDER BLOCKS" , tooltip = "Display swing volumetric order blocks")
css_swing_up = input.color (color.new(color.gray , 90) , " " , inline = "a", group = "VOLUMETRIC ORDER BLOCKS")
css_swing_dn = input.color (color.new(color.silver, 90) , "" , inline = "a", group = "VOLUMETRIC ORDER BLOCKS")
ob_filter = input.string ("None" , "Filtering " , inline = "d", group = "VOLUMETRIC ORDER BLOCKS" , tooltip = "Filter out volumetric order blocks by BOS/CHoCH/CHoCH+", options = )
ob_mitigation = input.string ("Absolute" , "Mitigation " , inline = "4", group = "VOLUMETRIC ORDER BLOCKS" , tooltip = "Trigger to remove volumetric order blocks", options = )
ob_pos = input.string ("Precise" , "Positioning " , inline = "k", group = "VOLUMETRIC ORDER BLOCKS" , tooltip = "Position of the Order Block\n Cover the whole candle\n Cover half candle\n Adjust to volatility\n Same as Accurate but more precise", options = )
use_grayscale = input.bool (false , "Grayscale" , inline = "6", group = "VOLUMETRIC ORDER BLOCKS" , tooltip = "Use gray as basic order blocks color")
use_show_metric = input.bool (true , "Show Metrics" , inline = "7", group = "VOLUMETRIC ORDER BLOCKS" , tooltip = "Show volume associated with the orderblock and his relevance")
use_middle_line = input.bool (true , "Show Middle-Line" , inline = "8", group = "VOLUMETRIC ORDER BLOCKS" , tooltip = "Show mid-line order blocks")
use_overlap = input.bool (true , "Hide Overlap" , inline = "9", group = "VOLUMETRIC ORDER BLOCKS" , tooltip = "Hide overlapping order blocks")
use_overlap_method = input.string ("Previous" , "Overlap Method " , inline = "Z", group = "VOLUMETRIC ORDER BLOCKS" , tooltip = " Preserve the most recent volumetric order blocks\n\n Preserve the previous volumetric order blocks", options = )
ob_bull_css = input.color (color.new(#089981 , 90) , "" , inline = "1", group = "VOLUMETRIC ORDER BLOCKS")
ob_bear_css = input.color (color.new(#f23645 , 90) , "" , inline = "1", group = "VOLUMETRIC ORDER BLOCKS")
show_acc_dist_zone = input.bool (false , "" , inline = "1", group = "Accumulation And Distribution")
zone_mode = input.string ("Fast" , "" , inline = "1", group = "Accumulation And Distribution" , tooltip = " Find small zone pattern formation\n Find bigger zone pattern formation" ,options = )
acc_css = input.color (color.new(#089981 , 60) , "" , inline = "1", group = "Accumulation And Distribution")
dist_css = input.color (color.new(#f23645 , 60) , "" , inline = "1", group = "Accumulation And Distribution")
show_lbl = input.bool (true , "Show swing point" , inline = "1", group = "High and Low" , tooltip = "Display swing point")
show_mtb = input.bool (true , "Show High/Low/Equilibrium" , inline = "2", group = "High and Low" , tooltip = "Display Strong/Weak High And Low and Equilibrium")
toplvl = input.color (color.red , "Premium Zone " , inline = "3", group = "High and Low")
midlvl = input.color (color.gray , "Equilibrium Zone" , inline = "4", group = "High and Low")
btmlvl = input.color (#089981 , "Discount Zone " , inline = "5", group = "High and Low")
fvg_enable = input.bool (false , " " , inline = "1", group = "FAIR VALUE GAP" , tooltip = "Display fair value gap")
what_fvg = input.string ("FVG" , "" , inline = "1", group = "FAIR VALUE GAP" , tooltip = "Display fair value gap", options = )
fvg_num = input.int (5 , "Show Last " , inline = "1a", group = "FAIR VALUE GAP" , tooltip = "Number of fvg to show")
fvg_upcss = input.color (color.new(#089981, 80) , "" , inline = "1", group = "FAIR VALUE GAP")
fvg_dncss = input.color (color.new(color.red , 80) , "" , inline = "1", group = "FAIR VALUE GAP")
fvg_extend = input.int (10 , "Extend FVG" , inline = "2", group = "FAIR VALUE GAP" , tooltip = "Extend the display of the FVG.")
fvg_src = input.string ("Close" , "Mitigation " , inline = "3", group = "FAIR VALUE GAP" , tooltip = " Use the close of the body as trigger\n\n Use the extreme point of the body as trigger", options = )
fvg_tf = input.timeframe ("" , "Timeframe " , inline = "4", group = "FAIR VALUE GAP" , tooltip = "Timeframe of the fair value gap")
t = color.t (ob_bull_css)
invcol = color.new (color.white , 100)
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{ - UDT }
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
type bar
float o = open
float c = close
float h = high
float l = low
float v = volume
int n = bar_index
int t = time
type Zphl
line top
line bottom
label top_label
label bottom_label
bool stopcross
bool sbottomcross
bool itopcross
bool ibottomcross
string txtup
string txtdn
float topy
float bottomy
float topx
float bottomx
float tup
float tdn
int tupx
int tdnx
float itopy
float itopx
float ibottomy
float ibottomx
float uV
float dV
type FVG
box box
line ln
bool bull
float top
float btm
int left
int right
type ms
float p
int n
float l
type msDraw
int n
float p
color css
string txt
bool bull
type obC
float top
float btm
int left
float avg
float dV
float cV
int wM
int blVP
int brVP
int dir
float h
float l
int n
type obD
box ob
box eOB
box blB
box brB
line mL
type zone
chart.point points
float p
int c
int t
type hqlzone
box pbx
box ebx
box lbx
label plb
label elb
label lbl
type ehl
float pt
int t
float pb
int b
type pattern
string found = "None"
bool isfound = false
int period = 0
bool bull = false
type alerts
bool chochswing = false
bool chochplusswing = false
bool swingbos = false
bool chochplus = false
bool choch = false
bool bos = false
bool equal = false
bool ob = false
bool swingob = false
bool zone = false
bool fvg = false
bool obtouch = false
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{ - End }
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{ - General Setup }
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
bar b = bar.new()
var pattern p = pattern.new()
alerts blalert = alerts.new()
alerts bralert = alerts.new()
if p.isfound
p.period += 1
if p.period == 50
p.period := 0
p.found := "None"
p.isfound := false
p.bull := na
switch
b.c > b.o => boolean.set(green_candle, true)
b.c < b.o => boolean.set(red_candle , true)
f_zscore(src, lookback) =>
(src - ta.sma(src, lookback)) / ta.stdev(src, lookback)
var int iLen = internal_r_lookback
var int sLen = swing_r_lookback
vv = f_zscore(((close - close ) / close ) * 100,iLen)
if ms_mode == "Dynamic"
switch
vv >= 1.5 or vv <= -1.5 => iLen := 10
vv >= 1.6 or vv <= -1.6 => iLen := 9
vv >= 1.7 or vv <= -1.7 => iLen := 8
vv >= 1.8 or vv <= -1.8 => iLen := 7
vv >= 1.9 or vv <= -1.9 => iLen := 6
vv >= 2.0 or vv <= -2.0 => iLen := 5
=> iLen
var msline = array.new(0)
iH = ta.pivothigh(high, iLen, iLen)
sH = ta.pivothigh(high, sLen, sLen)
iL = ta.pivotlow (low , iLen, iLen)
sL = ta.pivotlow (low , sLen, sLen)
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{ - End }
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{ - ARRAYS }
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
hl () =>
= request.security(syminfo.tickerid , 'D' , hl() , lookahead = barmerge.lookahead_on)
= request.security(syminfo.tickerid , 'W' , hl() , lookahead = barmerge.lookahead_on)
= request.security(syminfo.tickerid , 'M' , hl() , lookahead = barmerge.lookahead_on)
= request.security(syminfo.tickerid , '12M', hl() , lookahead = barmerge.lookahead_on)
lstyle(style) =>
out = switch style
'⎯⎯⎯' => line.style_solid
'----' => line.style_dashed
'····' => line.style_dotted
mtfphl(h, l ,tf ,css, pdhl_style) =>
var line hl = line.new(
na
, na
, na
, na
, xloc = xloc.bar_time
, color = css
, style = lstyle(pdhl_style)
)
var line ll = line.new(
na
, na
, na
, na
, xloc = xloc.bar_time
, color = css
, style = lstyle(pdhl_style)
)
var label lbl = label.new(
na
, na
, xloc = xloc.bar_time
, text = str.format('P{0}L', tf)
, color = invcol
, textcolor = css
, size = size.small
, style = label.style_label_left
)
var label hlb = label.new(
na
, na
, xloc = xloc.bar_time
, text = str.format('P{0}H', tf)
, color = invcol
, textcolor = css
, size = size.small
, style = label.style_label_left
)
hy = ta.valuewhen(h != h , h , 1)
hx = ta.valuewhen(h == high , time , 1)
ly = ta.valuewhen(l != l , l , 1)
lx = ta.valuewhen(l == low , time , 1)
if barstate.islast
extension = time + (time - time ) * 50
line.set_xy1(hl , hx , hy)
line.set_xy2(hl , extension , hy)
label.set_xy(hlb, extension , hy)
line.set_xy1(ll , lx , ly)
line.set_xy2(ll , extension , ly)
label.set_xy(lbl, extension , ly)
if lvl_daily
mtfphl(pdh , pdl , 'D' , css_d, s_d)
if lvl_weekly
mtfphl(pwh , pwl , 'W' , css_w, s_w)
if lvl_monthly
mtfphl(pmh , pml, 'M' , css_m, s_m)
if lvl_yearly
mtfphl(pyh , pyl , '12M', css_y, s_y)
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{ - End }
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{ - Market Structure }
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
method darkcss(color css, float factor, bool bull) =>
blue = color.b(css) * (1 - factor)
red = color.r(css) * (1 - factor)
green = color.g(css) * (1 - factor)
color.rgb(red, green, blue, 0)
method f_line(msDraw d, size, style) =>
var line id = na
var label lbl = na
id := line.new(
d.n
, d.p
, b.n
, d.p
, color = d.css
, width = 1
, style = style
)
if msline.size() >= 250
line.delete(msline.shift())
msline.push(id)
lbl := label.new(
int(math.avg(d.n, b.n))
, d.p
, d.txt
, color = invcol
, textcolor = d.css
, style = d.bull ? label.style_label_down : label.style_label_up
, size = size
, text_font_family = font.family_monospace
)
structure(bool mtf) =>
msDraw drw = na
bool isdrw = false
bool isdrwS = false
var color css = na
var color icss = na
var int itrend = 0
var int trend = 0
bool bull_ob = false
bool bear_ob = false
bool s_bull_ob = false
bool s_bear_ob = false
n = bar_index
var ms up = ms.new(
array.new()
, array.new< int >()
, array.new()
)
var ms dn = ms.new(
array.new()
, array.new< int >()
, array.new()
)
var ms sup = ms.new(
array.new()
, array.new< int >()
, array.new()
)
var ms sdn = ms.new(
array.new()
, array.new< int >()
, array.new()
)
switch show_swing_ms
"All" => boolean.set(s_BOS , true ), boolean.set(s_CHoCH, true ) , boolean.set(s_CHoCHP, true )
"CHoCH" => boolean.set(s_BOS , false), boolean.set(s_CHoCH, true ) , boolean.set(s_CHoCHP, false )
"CHoCH+" => boolean.set(s_BOS , false), boolean.set(s_CHoCH, false) , boolean.set(s_CHoCHP, true )
"BOS" => boolean.set(s_BOS , true ), boolean.set(s_CHoCH, false) , boolean.set(s_CHoCHP, false )
"None" => boolean.set(s_BOS , false), boolean.set(s_CHoCH, false) , boolean.set(s_CHoCHP, false )
=> na
switch show_internal_ms
"All" => boolean.set(i_BOS, true ), boolean.set(i_CHoCH, true ), boolean.set(i_CHoCHP, true )
"CHoCH" => boolean.set(i_BOS, false), boolean.set(i_CHoCH, true ), boolean.set(i_CHoCHP, false)
"CHoCH+" => boolean.set(i_BOS, false), boolean.set(i_CHoCH, false ), boolean.set(i_CHoCHP, true )
"BOS" => boolean.set(i_BOS, true ), boolean.set(i_CHoCH, false ), boolean.set(i_CHoCHP, false)
"None" => boolean.set(i_BOS, false), boolean.set(i_CHoCH, false ), boolean.set(i_CHoCHP, false)
=> na
switch
iH =>
up.p.unshift(b.h )
up.l.unshift(b.h )
up.n.unshift(n )
iL =>
dn.p.unshift(b.l )
dn.l.unshift(b.l )
dn.n.unshift(n )
sL =>
sdn.p.unshift(b.l )
sdn.l.unshift(b.l )
sdn.n.unshift(n )
sH =>
sup.p.unshift(b.h )
sup.l.unshift(b.h )
sup.n.unshift(n )
// INTERNAL BULLISH STRUCTURE
if up.p.size() > 0 and dn.l.size() > 1
if ta.crossover(b.c, up.p.first())
bool CHoCH = na
string txt = na
if itrend < 0
CHoCH := true
switch
not CHoCH =>
txt := "BOS"
css := i_ms_up_BOS
blalert.bos := true
if boolean.get(i_BOS) and mtf == false and na(drw)
isdrw := true
drw := msDraw.new(
up.n.first()
, up.p.first()
, i_ms_up_BOS
, txt
, true
)
CHoCH =>
dn.l.first() > dn.l.get(1) ? blalert.chochplus : blalert.choch
txt := dn.l.first() > dn.l.get(1) ? "CHoCH+" : "CHoCH"
css := i_ms_up_BOS.darkcss(0.25, true)
if (dn.l.first() > dn.l.get(1) ? boolean.get(i_CHoCHP) : boolean.get(i_CHoCH)) and mtf == false and na(drw)
isdrw := true
drw := msDraw.new(
up.n.first()
, up.p.first()
, i_ms_up_BOS.darkcss(0.25, true)
, txt
, true
)
if mtf == false
switch
ob_filter == "None" => bull_ob := true
ob_filter == "BOS" and txt == "BOS" => bull_ob := true
ob_filter == "CHoCH" and txt == "CHoCH" => bull_ob := true
ob_filter == "CHoCH+" and txt == "CHoCH+" => bull_ob := true
itrend := 1
up.n.clear()
up.p.clear()
// INTERNAL BEARISH STRUCTURE
if dn.p.size() > 0 and up.l.size() > 1
if ta.crossunder(b.c, dn.p.first())
bool CHoCH = na
string txt = na
if itrend > 0
CHoCH := true
switch
not CHoCH =>
bralert.bos := true
txt := "BOS"
css := i_ms_dn_BOS
if boolean.get(i_BOS) and mtf == false and na(drw)
isdrw := true
drw := msDraw.new(
dn.n.first()
, dn.p.first()
, i_ms_dn_BOS
, txt
, false
)
CHoCH =>
if up.l.first() < up.l.get(1)
bralert.chochplus := true
else
bralert.choch := true
txt := up.l.first() < up.l.get(1) ? "CHoCH+" : "CHoCH"
css := i_ms_dn_BOS.darkcss(0.25, false)
if (up.l.first() < up.l.get(1) ? boolean.get(i_CHoCHP) : boolean.get(i_CHoCH)) and mtf == false and na(drw)
isdrw := true
drw := msDraw.new(
dn.n.first()
, dn.p.first()
, i_ms_dn_BOS.darkcss(0.25, false)
, txt
, false
)
if mtf == false
switch
ob_filter == "None" => bear_ob := true
ob_filter == "BOS" and txt == "BOS" => bear_ob := true
ob_filter == "CHoCH" and txt == "CHoCH" => bear_ob := true
ob_filter == "CHoCH+" and txt == "CHoCH+" => bear_ob := true
itrend := -1
dn.n.clear()
dn.p.clear()
// SWING BULLISH STRUCTURE
if sup.p.size() > 0 and sdn.l.size() > 1
if ta.crossover(b.c, sup.p.first())
bool CHoCH = na
string txt = na
if trend < 0
CHoCH := true
switch
not CHoCH =>
blalert.swingbos := true
txt := "BOS"
icss := s_ms_up_BOS
if boolean.get(s_BOS) and mtf == false and na(drw)
isdrwS := true
drw := msDraw.new(
sup.n.first()
, sup.p.first()
, s_ms_up_BOS
, txt
, true
)
CHoCH =>
if sdn.l.first() > sdn.l.get(1)
blalert.chochplusswing := true
else
blalert.chochswing := true
txt := sdn.l.first() > sdn.l.get(1) ? "CHoCH+" : "CHoCH"
icss := s_ms_up_BOS.darkcss(0.25, true)
if (sdn.l.first() > sdn.l.get(1) ? boolean.get(s_CHoCHP) : boolean.get(s_CHoCH)) and mtf == false and na(drw)
isdrwS := true
drw := msDraw.new(
sup.n.first()
, sup.p.first()
, s_ms_up_BOS.darkcss(0.25, true)
, txt
, true
)
if mtf == false
switch
ob_filter == "None" => s_bull_ob := true
ob_filter == "BOS" and txt == "BOS" => s_bull_ob := true
ob_filter == "CHoCH" and txt == "CHoCH" => s_bull_ob := true
ob_filter == "CHoCH+" and txt == "CHoCH+" => s_bull_ob := true
trend := 1
sup.n.clear()
sup.p.clear()
// SWING BEARISH STRUCTURE
if sdn.p.size() > 0 and sup.l.size() > 1
if ta.crossunder(b.c, sdn.p.first())
bool CHoCH = na
string txt = na
if trend > 0
CHoCH := true
switch
not CHoCH =>
bralert.swingbos := true
txt := "BOS"
icss := s_ms_dn_BOS
if boolean.get(s_BOS) and mtf == false and na(drw)
isdrwS := true
drw := msDraw.new(
sdn.n.first()
, sdn.p.first()
, s_ms_dn_BOS
, txt
, false
)
CHoCH =>
if sup.l.first() < sup.l.get(1)
bralert.chochplusswing := true
else
bralert.chochswing := true
txt := sup.l.first() < sup.l.get(1) ? "CHoCH+" : "CHoCH"
icss := s_ms_dn_BOS.darkcss(0.25, false)
if (sup.l.first() < sup.l.get(1) ? boolean.get(s_CHoCHP) : boolean.get(s_CHoCH)) and mtf == false and na(drw)
isdrwS := true
drw := msDraw.new(
sdn.n.first()
, sdn.p.first()
, s_ms_dn_BOS.darkcss(0.25, false)
, txt
, false
)
if mtf == false
switch
ob_filter == "None" => s_bear_ob := true
ob_filter == "BOS" and txt == "BOS" => s_bear_ob := true
ob_filter == "CHoCH" and txt == "CHoCH" => s_bear_ob := true
ob_filter == "CHoCH+" and txt == "CHoCH+" => s_bear_ob := true
trend := -1
sdn.n.clear()
sdn.p.clear()
= structure(false)
if isdrw
f_line(drw, size.small, line.style_dashed)
if isdrwS
f_line(drw, size.small, line.style_solid)
= request.security("", "15" , structure(true))
= request.security("", "60" , structure(true))
= request.security("", "240" , structure(true))
= request.security("", "1440" , structure(true))
if show_mtf_str
var tab = table.new(position = position.top_right, columns = 10, rows = 10, bgcolor = na, frame_color = color.rgb(54, 58, 69, 0), frame_width = 1, border_color = color.rgb(54, 58, 69, 100), border_width = 1)
table.cell(tab, 0, 1, text = "15" , text_color = color.silver, text_halign = text.align_center, text_size = size.normal, bgcolor = chart.bg_color, text_font_family = font.family_monospace, width = 2)
table.cell(tab, 0, 2, text = "1H" , text_color = color.silver, text_halign = text.align_center, text_size = size.normal, bgcolor = chart.bg_color, text_font_family = font.family_monospace, width = 2)
table.cell(tab, 0, 3, text = "4H" , text_color = color.silver, text_halign = text.align_center, text_size = size.normal, bgcolor = chart.bg_color, text_font_family = font.family_monospace, width = 2)
table.cell(tab, 0, 4, text = "1D" , text_color = color.silver, text_halign = text.align_center, text_size = size.normal, bgcolor = chart.bg_color, text_font_family = font.family_monospace, width = 2)
table.cell(tab, 1, 1, text = itrend15 == 1 ? "BULLISH" : itrend15 == -1 ? "BEARISH" : na , text_halign = text.align_center, text_size = size.normal, text_color = itrend15 == 1 ? i_ms_up_BOS.darkcss(-0.25, true) : itrend15 == -1 ? i_ms_dn_BOS.darkcss(0.25, false) : color.gray, bgcolor = chart.bg_color, text_font_family = font.family_monospace)
table.cell(tab, 1, 2, text = itrend1H == 1 ? "BULLISH" : itrend1H == -1 ? "BEARISH" : na , text_halign = text.align_center, text_size = size.normal, text_color = itrend1H == 1 ? i_ms_up_BOS.darkcss(-0.25, true) : itrend1H == -1 ? i_ms_dn_BOS.darkcss(0.25, false) : color.gray, bgcolor = chart.bg_color, text_font_family = font.family_monospace)
table.cell(tab, 1, 3, text = itrend4H == 1 ? "BULLISH" : itrend4H == -1 ? "BEARISH" : na , text_halign = text.align_center, text_size = size.normal, text_color = itrend4H == 1 ? i_ms_up_BOS.darkcss(-0.25, true) : itrend4H == -1 ? i_ms_dn_BOS.darkcss(0.25, false) : color.gray, bgcolor = chart.bg_color, text_font_family = font.family_monospace)
table.cell(tab, 1, 4, text = itrend1D == 1 ? "BULLISH" : itrend1D == -1 ? "BEARISH" : na , text_halign = text.align_center, text_size = size.normal, text_color = itrend1D == 1 ? i_ms_up_BOS.darkcss(-0.25, true) : itrend1D == -1 ? i_ms_dn_BOS.darkcss(0.25, false) : color.gray, bgcolor = chart.bg_color, text_font_family = font.family_monospace)
table.cell(tab, 0, 5, text = "Detected Pattern", text_halign = text.align_center, text_size = size.normal, text_color = color.silver, bgcolor = chart.bg_color, text_font_family = font.family_monospace)
table.cell(tab, 0, 6, text = p.found, text_halign = text.align_center, text_size = size.normal, text_color = na(p.bull) ? color.white : p.bull ? i_ms_up_BOS.darkcss(-0.25, true) : p.bull == false ? i_ms_dn_BOS.darkcss(0.25, false) : na, bgcolor = chart.bg_color, text_font_family = font.family_monospace)
table.merge_cells(tab, 0, 5, 1, 5)
table.merge_cells(tab, 0, 6, 1, 6)
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{ - End }
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{ - Strong/Weak High/Low And Equilibrium }
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
var phl = Zphl.new(
na
, na
, label.new(na , na , color = invcol , textcolor = i_ms_dn_BOS , style = label.style_label_down , size = size.tiny , text = "")
, label.new(na , na , color = invcol , textcolor = i_ms_up_BOS , style = label.style_label_up , size = size.tiny , text = "")
, true
, true
, true
, true
, ""
, ""
, 0
, 0
, 0
, 0
, high
, low
, 0
, 0
, 0
, 0
, 0
, 0
, na
, na
)
zhl(len)=>
upper = ta.highest(len)
lower = ta.lowest(len)
var float out = 0
out := b.h > upper ? 0 : b.l < lower ? 1 : out
top = out == 0 and out != 0 ? b.h : 0
btm = out == 1 and out != 1 ? b.l : 0
= zhl(sLen)
= zhl(iLen)
upphl(trend) =>
var label lbl = label.new(
na
, na
, color = invcol
, textcolor = toplvl
, style = label.style_label_down
, size = size.small
)
if top
phl.stopcross := true
phl.txtup := top > phl.topy ? "HH" : "HL"
if show_lbl
topl = label.new(
b.n - swing_r_lookback
, top
, phl.txtup
, color = invcol
, textcolor = toplvl
, style = label.style_label_down
, size = size.small
)
line.delete(phl.top )
phl.top := line.new(
b.n - sLen
, top
, b.n
, top
, color = toplvl)
phl.topy := top
phl.topx := b.n - sLen
phl.tup := top
phl.tupx := b.n - sLen
if itop
phl.itopcross := true
phl.itopy := itop
phl.itopx := b.n - iLen
phl.tup := math.max(high, phl.tup)
phl.tupx := phl.tup == high ? b.n : phl.tupx
phl.uV := phl.tup != phl.tup ? b.v : phl.uV
if barstate.islast
line.set_xy1(
phl.top
, phl.tupx
, phl.tup
)
line.set_xy2(
phl.top
, b.n + 50
, phl.tup
)
label.set_x(
lbl
, b.n + 50
)
label.set_y(
lbl
, phl.tup
)
dist = math.abs(phl.uV / (phl.uV + phl.dV)) * 100
label.set_text (lbl, trend < 0
? "Strong High | " + str.tostring(phl.uV, format.volume) + " (" + str.tostring(math.round(dist,0)) + "%)"
: "Weak High | " + str.tostring(phl.uV, format.volume) + " (" + str.tostring(math.round(dist,0)) + "%)")
dnphl(trend) =>
var label lbl = label.new(
na
, na
, color = invcol
, textcolor = btmlvl
, style = label.style_label_up
, size = size.small
)
if btm
phl.sbottomcross := true
phl.txtdn := btm > phl.bottomy ? "LH" : "LL"
if show_lbl
btml = label.new(
b.n - swing_r_lookback
, btm, phl.txtdn
, color = invcol
, textcolor = btmlvl
, style = label.style_label_up
, size = size.small
)
line.delete(phl.bottom )
phl.bottom := line.new(
b.n - sLen
, btm
, b.n
, btm
, color = btmlvl
)
phl.bottomy := btm
phl.bottomx := b.n - sLen
phl.tdn := btm
phl.tdnx := b.n - sLen
if ibtm
phl.ibottomcross := true
phl.ibottomy := ibtm
phl.ibottomx := b.n - iLen
phl.tdn := math.min(low, phl.tdn)
phl.tdnx := phl.tdn == low ? b.n : phl.tdnx
phl.dV := phl.tdn != phl.tdn ? b.v : phl.dV
if barstate.islast
line.set_xy1(
phl.bottom
, phl.tdnx
, phl.tdn
)
line.set_xy2(
phl.bottom
, b.n + 50
, phl.tdn
)
label.set_x(
lbl
, b.n + 50
)
label.set_y(
lbl
, phl.tdn
)
dist = math.abs(phl.dV / (phl.uV + phl.dV)) * 100
label.set_text (lbl, trend > 0
? "Strong Low | " + str.tostring(phl.dV, format.volume) + " (" + str.tostring(math.round(dist,0)) + "%)"
: "Weak Low | " + str.tostring(phl.uV, format.volume) + " (" + str.tostring(math.round(dist,0)) + "%)")
midphl() =>
avg = math.avg(phl.bottom.get_y2(), phl.top.get_y2())
var line l = line.new(
y1 = avg
, y2 = avg
, x1 = b.n - sLen
, x2 = b.n + 50
, color = midlvl
, style = line.style_solid
)
var label lbl = label.new(
x = b.n + 50
, y = avg
, text = "Equilibrium"
, style = label.style_label_left
, color = invcol
, textcolor = midlvl
, size = size.small
)
if barstate.islast
more = (phl.bottom.get_x1() + phl.bottom.get_x2()) > (phl.top.get_x1() + phl.top.get_x2()) ? phl.top.get_x1() : phl.bottom.get_x1()
line.set_xy1(l , more , avg)
line.set_xy2(l , b.n + 50, avg)
label.set_x (lbl , b.n + 50 )
label.set_y (lbl , avg )
dist = math.abs((l.get_y2() - close) / close) * 100
label.set_text (lbl, "Equilibrium (" + str.tostring(math.round(dist,0)) + "%)")
hqlzone() =>
if barstate.islast
var hqlzone dZone = hqlzone.new(
box.new(
na
, na
, na
, na
, bgcolor = color.new(toplvl, 70)
, border_color = na
)
, box.new(
na
, na
, na
, na
, bgcolor = color.new(midlvl, 70)
, border_color = na
)
, box.new(
na
, na
, na
, na
, bgcolor = color.new(btmlvl, 70)
, border_color = na
)
, label.new(na, na, text = "Premium" , color = invcol, textcolor = toplvl, style = label.style_label_down, size = size.small)
, label.new(na, na, text = "Equilibrium", color = invcol, textcolor = midlvl, style = label.style_label_left, size = size.small)
, label.new(na, na, text = "Discount" , color = invcol, textcolor = btmlvl, style = label.style_label_up , size = size.small)
)
dZone.pbx.set_lefttop(int(math.max(phl.topx, phl.bottomx)) , phl.tup)
dZone.pbx.set_rightbottom(b.n + 50 , 0.95 * phl.tup + 0.05 * phl.tdn)
dZone.ebx.set_lefttop(int(math.max(phl.topx, phl.bottomx)), 0.525 * phl.tup + 0.475 * phl.tdn)
dZone.ebx.set_rightbottom(b.n + 50 , 0.525 * phl.tdn + 0.475 * phl.tup)
dZone.lbx.set_lefttop(int(math.max(phl.topx, phl.bottomx)), 0.95 * phl.tdn + 0.05 * phl.tup)
dZone.lbx.set_rightbottom(b.n + 50 , phl.tdn)
dZone.plb.set_xy( int(math.avg(math.max(phl.topx, phl.bottomx), int(b.n + 50))) , phl.tup)
dZone.elb.set_xy( int(b.n + 50) , math.avg(phl.tup, phl.tdn))
dZone.lbl.set_xy( int(math.avg(math.max(phl.topx, phl.bottomx), int(b.n + 50))) , phl.tdn)
if show_mtb
upphl (trend)
dnphl (trend)
hqlzone()
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{ - End }
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{ - Volumetric Order Block }
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
method eB(box b, bool ext, color css, bool swing) =>
b.unshift(
box.new(
na
, na
, na
, na
, xloc = xloc.bar_time
, text_font_family = font.family_monospace
, extend = ext ? extend.right : extend.none
, border_color = swing ? color.new(css, 0) : color.new(color.white,100)
, bgcolor = css
, border_width = 1
)
)
method eL(line l, bool ext, bool solid, color css) =>
l.unshift(
line.new(
na
, na
, na
, na
, width = 1
, color = css
, xloc = xloc.bar_time
, extend = ext ? extend.right : extend.none
, style = solid ? line.style_solid : line.style_dashed
)
)
method drawVOB(bool cdn, bool bull, color css, int loc, bool swing) =>
= request.security(
syminfo.tickerid
, ""
,
, lookahead = barmerge.lookahead_off
)
var obC obj = obC.new(
array.new()
, array.new()
, array.new< int >()
, array.new()
, array.new()
, array.new()
, array.new< int >()
, array.new< int >()
, array.new< int >()
, array.new< int >()
, array.new()
, array.new()
, array.new< int >()
)
var obD draw = obD.new(
array.new()
, array.new()
, array.new()
, array.new()
, array.new()
)
if barstate.isfirst
for i = 0 to ob_num - 1
draw.mL .eL(false, false, use_grayscale ? color.new(color.gray, 0) : color.new(css,0))
draw.ob .eB(false, use_grayscale ? color.new(color.gray, 90) : css, swing)
draw.blB.eB(false, css_metric_up , swing)
draw.brB.eB(false, css_metric_dn , swing)
draw.eOB.eB(true , use_grayscale ? color.new(color.gray, 90) : css, swing)
float pos = ob_pos == "Full"
? (bull ? high : low)
: ob_pos == "Middle"
? ohlc4
: ob_pos == "Accurate"
? hl2
: hl2
if cdn
obj.h.clear()
obj.l.clear()
obj.n.clear()
for i = 0 to math.abs((loc - b.n)) - 1
obj.h.push(hH )
obj.l.push(lL )
obj.n.push(b.t )
// obj.h.reverse()
// obj.l.reverse()
int iU = obj.l.indexof(obj.l.min()) + 1
int iD = obj.h.indexof(obj.h.max()) + 1
obj.dir.unshift(
bull
? (b.c > b.o ? 1 : -1)
: (b.c > b.o ? 1 : -1)
)
obj.top.unshift(
bull
? pos
: obj.h.max()
)
obj.btm.unshift(
bull
? obj.l.min()
: pos
)
obj.left.unshift(
bull
? obj.n.get(obj.l.indexof(obj.l.min()))
: obj.n.get(obj.h.indexof(obj.h.max()))
)
obj.avg.unshift(
math.avg(obj.top.first(), obj.btm.first())
)
obj.cV.unshift(
bull
? b.v
: b.v
)
if ob_pos == "Precise"
switch bull
true =>
if obj.avg.get(0) < (b.c < b.o ? b.c : b.o ) and obj.top.get(0) > hlcc4
obj.top.set(0, obj.avg.get(0))
obj.avg.set(0, math.avg(obj.top.first(), obj.btm.first()))
false =>
if obj.avg.get(0) > (b.c < b.o ? b.o : b.c ) and obj.btm.get(0) < hlcc4
obj.btm.set(0, obj.avg.get(0))
obj.avg.set(0, math.avg(obj.top.first(), obj.btm.first()))
obj.blVP.unshift ( 0 )
obj.brVP.unshift ( 0 )
obj.wM .unshift ( 1 )
if use_overlap
int rmP = use_overlap_method == "Recent" ? 1 : 0
if obj.avg.size() > 1
if bull
? obj.btm.first() < obj.top.get(1)
: obj.top.first() > obj.btm.get(1)
obj.wM .remove(rmP)
obj.cV .remove(rmP)
obj.dir .remove(rmP)
obj.top .remove(rmP)
obj.avg .remove(rmP)
obj.btm .remove(rmP)
obj.left .remove(rmP)
obj.blVP .remove(rmP)
obj.brVP .remove(rmP)
if barstate.isconfirmed
for x = 0 to ob_num - 1
tg = switch ob_mitigation
"Middle" => obj.avg
"Absolute" => bull ? obj.btm : obj.top
for in tg
if (bull ? cC < pt : cC > pt)
obj.wM .remove(idx)
obj.cV .remove(idx)
obj.dir .remove(idx)
obj.top .remove(idx)
obj.avg .remove(idx)
obj.btm .remove(idx)
obj.left .remove(idx)
obj.blVP .remove(idx)
obj.brVP .remove(idx)
if barstate.islast
if obj.avg.size() > 0
// Alert
if bull
? ta.crossunder(low , obj.top.get(0))
: ta.crossover (high, obj.btm.get(0))
switch bull
true => blalert.obtouch := true
false => bralert.obtouch := true
float tV = 0
obj.dV.clear()
seq = math.min(ob_num - 1, obj.avg.size() - 1)
for j = 0 to seq
tV += obj.cV.get(j)
if j == seq
for y = 0 to seq
obj.dV.unshift(
math.floor(
(obj.cV.get(y) / tV) * 100)
)
obj.dV.reverse()
for i = 0 to math.min(ob_num - 1, obj.avg.size() - 1)
dmL = draw.mL .get(i)
dOB = draw.ob .get(i)
dblB = draw.blB.get(i)
dbrB = draw.brB.get(i)
deOB = draw.eOB.get(i)
dOB.set_lefttop (obj.left .get(i) , obj.top.get(i))
deOB.set_lefttop (b.t , obj.top.get(i))
dOB.set_rightbottom (b.t , obj.btm.get(i))
deOB.set_rightbottom(b.t + (b.t - b.t ) * 100 , obj.btm.get(i))
if use_middle_line
dmL.set_xy1(obj.left.get(i), obj.avg.get(i))
dmL.set_xy2(b.t , obj.avg.get(i))
if ob_metrics_show
dblB.set_lefttop (obj.left.get(i), obj.top.get(i))
dbrB.set_lefttop (obj.left.get(i), obj.avg.get(i))
dblB.set_rightbottom(obj.left.get(i), obj.avg.get(i))
dbrB.set_rightbottom(obj.left.get(i), obj.btm.get(i))
rpBL = dblB.get_right()
rpBR = dbrB.get_right()
dbrB.set_right(rpBR + (b.t - b.t ) * obj.brVP.get(i))
dblB.set_right(rpBL + (b.t - b.t ) * obj.blVP.get(i))
if use_show_metric
txt = switch
obj.cV.get(i) >= 1000000000 => str.tostring(math.round(obj.cV.get(i) / 1000000000,3)) + "B"
obj.cV.get(i) >= 1000000 => str.tostring(math.round(obj.cV.get(i) / 1000000,3)) + "M"
obj.cV.get(i) >= 1000 => str.tostring(math.round(obj.cV.get(i) / 1000,3)) + "K"
obj.cV.get(i) < 1000 => str.tostring(math.round(obj.cV.get(i)))
deOB.set_text(
str.tostring(
txt + " (" + str.tostring(obj.dV.get(i)) + "%)")
)
deOB.set_text_size (size.auto)
deOB.set_text_halign(text.align_left)
deOB.set_text_color (use_grayscale ? color.silver : color.new(css, 0))
if ob_metrics_show and barstate.isconfirmed
if obj.wM.size() > 0
for i = 0 to obj.avg.size() - 1
switch obj.dir.get(i)
1 =>
switch obj.wM.get(i)
1 => obj.blVP.set(i, obj.blVP.get(i) + 1), obj.wM.set(i, 2)
2 => obj.blVP.set(i, obj.blVP.get(i) + 1), obj.wM.set(i, 3)
3 => obj.brVP.set(i, obj.brVP.get(i) + 1), obj.wM.set(i, 1)
-1 =>
switch obj.wM.get(i)
1 => obj.brVP.set(i, obj.brVP.get(i) + 1), obj.wM.set(i, 2)
2 => obj.brVP.set(i, obj.brVP.get(i) + 1), obj.wM.set(i, 3)
3 => obj.blVP.set(i, obj.blVP.get(i) + 1), obj.wM.set(i, 1)
var hN = array.new(1, b.n)
var lN = array.new(1, b.n)
var hS = array.new(1, b.n)
var lS = array.new(1, b.n)
if iH
hN.pop()
hN.unshift(int(b.n ))
if iL
lN.pop()
lN.unshift(int(b.n ))
if sH
hS.pop()
hS.unshift(int(b.n ))
if sL
lS.pop()
lS.unshift(int(b.n ))
if ob_show
bull_ob.drawVOB(true , ob_bull_css, hN.first(), false)
bear_ob.drawVOB(false, ob_bear_css, lN.first(), false)
if ob_swings
s_bull_ob.drawVOB(true , css_swing_up, hS.first(), true)
s_bear_ob.drawVOB(false, css_swing_dn, lS.first(), true)
if bull_ob
blalert.ob := true
if bear_ob
bralert.ob := true
if s_bull_ob
blalert.swingob := true
if s_bear_ob
blalert.swingob := true
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{ - End }
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{ - FVG | VI | OG }
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
//{----------------------------------------------------------------------------------------------------------------------------------------------}
ghl() => request.security(syminfo.tickerid, fvg_tf, [high , low , close , open ])
tfG() => request.security(syminfo.tickerid, fvg_tf, )
cG(bool bull) =>
= ghl()
= tfG()
var FVG draw = FVG.new(
array.new()
, array.new()
)
var FVG cords = array.new()
float pup = na
float pdn = na
bool cdn = na
int pos = 2
cc = timeframe.change(fvg_tf)
if barstate.isfirst
for i = 0 to fvg_num - 1
draw.box.unshift(box.new (na, na, na, na, border_color = color.new(color.white, 100), xloc = xloc.bar_time))
draw.ln.unshift (line.new(na, na, na, na, xloc = xloc.bar_time, width = 1, style = line.style_solid))
switch what_fvg
"FVG" =>
pup := bull ? gl : l
pdn := bull ? h : gh
cdn := bull ? gl > h and cc : gh < l and cc
pos := 2
"VI" =>
pup := bull
? (gc > go
? go
: gc)
: (gc > go
? go
: gc )
pdn := bull
? (gc > go
? gc
: go )
: (gc > go
? gc
: go)
cdn := bull
? go > gc and gh > gl and gc > gc and go > go and gh < math.min(gc, go) and cc
: go < gc and gl < gh and gc < gc and go < go and gl > math.max(gc, go) and cc
pos := 1
"OG" =>
pup := bull ? b.l : gl
pdn := bull ? gh : gh
cdn := bull ? gl > gh and cc : gh < gl and cc
pos := 1
if not na(cdn ) and cdn
cords.unshift(
FVG.new(
na
, na
, bull
? true
MirPapa:ICT:HTF: FVG OB Threeple# MirPapa:ICT:HTF: FVG OB (Fair Value Gap Order Block)
**Version:** Pine Script® v6
**Author:** © goodia
**License:** MPL-2.0 (Mozilla Public License 2.0)
---
## Overview
“FVG OB” (Fair Value Gap Order Block) identifies higher-timeframe candle ranges where a gap (imbalance) exists between two non-consecutive candles, signaling potential institutional order blocks. This module draws bullish or bearish FVG OB boxes on your lower-timeframe chart, extends them until price interacts a specified number of times, and then finalizes (recolors) the box.
---
## Inputs
- **Enable FVG OB Boxes** (`bool`)
Toggle drawing of HTF FVG OB boxes on the chart.
- **Enable FVG OB Midlines** (`bool`)
Toggle drawing of a midpoint line inside each FVG OB box.
- **FVG OB Close Count** (`int` 1–10)
Number of HTF closes beyond the FVG range required to finalize (recolor) the box.
- **FVG OB Bull Color** (`color`)
Fill & border color for bullish FVG OB boxes.
- **FVG OB Bear Color** (`color`)
Fill & border color for bearish FVG OB boxes.
- **FVG OB Box Transparency** (`int` 1–100)
Opacity level for FVG OB box fills (higher = more transparent).
---
## How It Works
1. **HTF Data Retrieval**
- The script uses `request.security()` (via `GetHTFrevised()`) to fetch HTF OHLC and historical values:
- `_htfHigh3` (high three bars ago) and `_htfLow1` (low one bar ago) for bullish FVG OB.
- `_htfLow3` (low three bars ago) and `_htfHigh1` (high one bar ago) for bearish FVG OB.
- It also tracks the HTF `bar_index` on the lower timeframe to align drawing.
2. **FVG OB Detection**
- **Bullish FVG OB**: Occurs when the HTF low of the previous bar (`low `) is strictly above the HTF high of three bars ago (`high `), creating a gap.
- **Bearish FVG OB**: Occurs when the HTF high of the previous bar (`high `) is strictly below the HTF low of three bars ago (`low `), creating a gap.
3. **Box Creation**
- On each new HTF bar (`ta.change(time(HTF)) != 0`), if a bullish or bearish FVG OB condition is met, the script calls `CreateBoxData()` with:
- **Bullish**: `bottom = HTF low `, `top = HTF high `, `_isBull = true`.
- **Bearish**: `bottom = HTF low `, `top = HTF high `, `_isBull = false`.
- Midline toggled by input.
- A `BoxData` struct is created and stored in either the Bull or Bear array.
4. **Box Extension & Finalization**
- On **every LTF bar**, `ProcessBoxDatas(...)` iterates over all active FVG OB boxes:
1. **Extend Right Edge**: `box.set_right(bar_index)` ensures the box follows the latest bar.
2. **Record Volume Delta**: Tracks buy/sell volume inside the box.
3. **Touch Stage Update**: `modBoxUpdateStage()` increments `_stage` when price touches its “basePoint” (for FVG OB, the basePrice is one side of the gap).
4. **Finalize**: `setBoxFinalize()` checks if the configured number of closes beyond the FVG gap (`FVG OB Close Count`) has occurred. If so:
- `_isActive := false`
- Border and background colors are changed to the “Box Close Color” (input).
- Finalized boxes remain on screen semi-transparent, indicating that the FVG OB zone has been tested.
5. **Midline (Optional)**
- If “Enable FVG OB Midlines” is checked, `ProcessBoxDatas()` also extends a horizontal midpoint line inside the box with `line.set_x2(bar_index)`.
---
## Usage Instructions
1. **Installation**
- Copy the FVG OB section of the Pine Script into TradingView’s Pine Editor (ensure the library import is included).
- Click “Add to Chart.”
2. **Configure Inputs**
- Choose a Higher Time Frame via the dropdown (e.g., “4시간” maps to a 4H timeframe).
- Toggle “Enable FVG OB Boxes” and “Enable FVG OB Midlines.”
- Select colors for bullish and bearish boxes and set transparency.
- Adjust “FVG OB Close Count” to control how many closes beyond the gap finalize the box.
3. **Interpretation**
- **Active FVG OB Boxes** extend to the right until price closes beyond the gap range the specified number of times.
- When finalized, each box changes to the “Box Close Color,” signaling that institutional orders in that gap have likely been filled.
Enjoy precise visualization of higher-timeframe Fair Value Gap Order Blocks on your lower-timeframe chart!
Mxwll Price Action Suite [Mxwll]Introducing the Mxwll Price Action Suite!
The Mxwll Price Action Suite is an all-in-one analysis indicator incorporating elements of SMC and also ideas extending beyond the trading methodology!
Features
Internal structures
External structures
Customizable Sensitivities
BoS/CHoCH
Order Blocks
HH/LH/LL/LH Areas
Rolling TF highs/lows
Rolling Volume Comparisons
Auto Fibs
And more!
The image above shows the indicator's market structure identification capabilities. Internal BoS and CHoCH structures in addition to overarching market structures are available with customizable sensitivities.
The image above shows the indicator identifying order blocks! Additionally, HH/LH/LL/LH areas are also identified.
The image above shows a rolling area of interest. These areas can be compared to supply/demand zones, where traders might consider a bargain long/short/sell area.
The indicator displays a rolling 4hr high/low and 1D high/low, alongside auto fibonacci levels with a customizable sensitivity.
Finally, the Mxwll Price Action Suite shows relevant session information.
Table information
Current Session
Countdown to session close
Next Session
Countdown to next session open
Rolling 4-Hr volume intensity
Rolling 24-Hr volume intensity
Introducing the Mxwll SMC Suite!
The Mxwll SMC Suite is an all-in-one analysis indicator incorporating elements of SMC and also ideas extending beyond the trading methodology!
Features
Internal structures
External structures
Customizable Sensitivities
BoS/CHoCH
Order Blocks
HH/LH/LL/LH Areas
Rolling TF highs/lows
Rolling Volume Comparisons
Auto Fibs
And more!
The image above shows the indicator's market structure identification capabilities. Internal BoS and CHoCH structures in addition to overarching market structures are available with customizable sensitivities.
The image above shows the indicator identifying order blocks! Additionally, HH/LH/LL/LH areas are also identified.
The image above shows a rolling area of interest. These areas can be compared to supply/demand zones, where traders might consider a bargain long/short/sell area.
The indicator displays a rolling 4hr high/low and 1D high/low, alongside auto fibonacci levels with a customizable sensitivity.
Finally, the Mxwll Price Action Suite shows relevant session information.
Table information
Current Session
Countdown to session close
Next Session
Countdown to next session open
Rolling 4-Hr volume intensity
Rolling 24-Hr volume intensity
Expanded Features of Mxwll Price Action Suite
Internal and External Structures
Internal Structures: These elements refer to the price formations and patterns that occur within a smaller scope or a specific trading session. The suite can detect intricate details like minor support/resistance levels or short-term trend reversals.
External Structures: These involve larger, more significant market patterns and trends spanning multiple sessions or time frames. This capability helps traders understand overarching market directions.
Customizable Sensitivities
Adjusting sensitivity settings allows users to tailor the indicator's responsiveness to market changes. Higher sensitivity can catch smaller fluctuations, while lower sensitivity might focus on more significant, reliable market moves.
Break of Structure (BoS) and Change of Character (CHoCH)
BoS: This feature identifies points where the price breaks a significant structure, potentially indicating a new trend or a trend reversal.
CHoCH: Detects subtle shifts in the market's behavior, which could suggest the early stages of a trend change before they become apparent to the broader market.
Order Blocks and Market Phases
Order Blocks: These are essentially price levels or zones where significant trading activities previously occurred, likely pointing to the positions of smart money.
HH/LH/LL/LH Areas: Identifying Higher Highs (HH), Lower Highs (LH), Lower Lows (LL), and Lower Highs (LH) helps in understanding the trend and market structure, aiding in predictive analysis.
Rolling Timeframe Highs/Lows and Volume Comparisons
Tracks highs and lows over specified rolling periods, providing dynamic support and resistance levels.
Compares volume data across different timeframes to assess the strength or weakness of the current price movements.
Auto Fibonacci Levels
Automatically calculates and plots Fibonacci retracement levels, a popular tool among traders to identify potential reversal points based on past movements.
Session Data and Volume Intensity
Session Information: Displays current and upcoming trading sessions along with countdown timers, which is crucial for day traders and those trading on session overlaps.
Volume Intensity: Measures and compares the volume within the last 4 hours and 24 hours to gauge market activity and potential breakout/breakdown movements.
Visualizations and Practical Use
Dynamic Visuals: The suite provides dynamic visual aids, such as real-time updating of high/low markers and Fibonacci levels, which adjust as new data comes in. This feature is critical in fast-paced markets.
Strategic Entry/Exit Points: By identifying order blocks and using Fibonacci levels, traders can pinpoint strategic entry and exit points, maximizing potential returns.
Risk Management: Enhanced features like session countdowns and volume intensity help in better risk management by providing traders with more data on market sentiment and potential volatility.
[JL] Fractals ATR BlockI decided to combine Fractal ROC , ATR Break, and Order Blocks to an Indicator
The Fractal ROC , ATR Break, and Order Blocks indicator combines three concepts to help traders identify potential trade opportunities and manage risk. By using a combination of Fractal ROC , ATR Break, and Order Blocks, traders can gain a deeper understanding of market dynamics and make more informed trading decisions.
Fractal ROC is a momentum-based indicator that calculates the rate of change of the price between fractals, which are turning points in the market. It is calculated by taking the difference between the closing price and the lowest price in the previous n+1 periods, and dividing it by the difference between the open price 2n periods ago and the lowest price in the previous n+1 periods. This calculation is done for both up and down fractals. When the Fractal ROC value is greater than the ROC Break Level (as determined by the input variable roclevel), it indicates a potential momentum shift in the market. This can be used to identify potential trade entries or exits, depending on your trading strategy.
ATR Break is an indicator that helps traders identify significant price movements in the market. It measures the distance between the price and the Average True Range (ATR), which is a measure of the volatility of the market. ATR Break is calculated by taking the difference between the close and high/low, and dividing it by the previous ATR value. This calculation is done for both up and down movements. When the ATR Break value is greater than the ATR Break Level (as determined by the input variable atrlevel), it indicates a significant move in the market. This can be used to identify potential breakouts or breakdowns, and can be used to set stop-loss and take-profit levels.
An Order Block is a price level where significant buying or selling activity has taken place. The order blocks made by ATR Break and Fractal ROC are drawn using boxes on the chart. When the ATR or Fractal ROC level is breached, a box is drawn with the high and low of the candle that breached the level as the top and bottom of the box, respectively. The box is then extended to the right until the end of the chart or until another ATR or Fractal ROC level is breached, at which point a new box is drawn. This allows traders to easily identify significant price movements and potential support and resistance levels on the chart. When an Order Block is identified, it can be used as a potential support or resistance level . If price approaches an Order Block from below, it is likely to bounce off this level and continue in an upward direction. Similarly, if price approaches an Order Block from above, it is likely to bounce off this level and continue in a downward direction. Traders can use these levels to identify potential trade entries or exits, as well as to set stop-loss and take-profit levels.
Overall, the Fractal ROC , ATR Break, and Order Blocks indicator is a powerful tool for traders who want to identify potential trade opportunities and manage risk. By combining these three concepts, traders can gain a deeper understanding of market dynamics and make more informed trading decisions. As with any indicator, it is important to use it in conjunction with other analysis tools and to have a clear trading plan in place.
Multi Indicator SummaryPurpose: It calculates and displays bullish and bearish order blocks, key levels derived from recent price movements, which traders use to identify potential support and resistance areas.
Inputs: Users can customize the order block length, defining the range of price data used for calculations.
Logic: The script uses ta.lowest and ta.highest functions to compute order blocks based on specified periods for bullish and bearish trends.
Additional Levels: It identifies extra order blocks (bullish_below and bearish_above) to provide more context for deeper support or higher resistance.
Price Table: A visual table is created on the chart, showing the current price, bullish and bearish order blocks, and additional bearish levels above the current price.
Alerts: Alerts are triggered when the price crosses key order block levels, helping traders react to significant price movements.
Flexibility: The table dynamically updates based on the chart’s ticker and timeframe, ensuring it always reflects the latest data.
Bearish Above Price: Highlights the most recent bearish order block above the current price to inform traders about potential resistance areas.
Visualization: The clear table format aids quick decision-making by summarizing key levels in an accessible way.
Usability: This script is especially useful for intraday and swing traders seeking to integrate order block analysis into their strategies.
16. SMC Strategy with SL - low TimeframeOverview
The "SMC Strategy with SL - low Timeframe" is a comprehensive trading strategy that uses key concepts from Smart Money Theory to identify favorable areas in the market for buying or selling. This strategy takes advantage of price imbalances, support and resistance zones, and swing highs/lows to generate high-probability trade signals.
The key features of this strategy include:
Swing High/Low Analysis: Used to determine the Premium, Equilibrium, and Discount Zones.
Order Block Integration: An added layer of confluence to identify valid buy and sell signals.
Trend Direction Confirmation: Using a Simple Moving Average (SMA) to determine the overall trend.
Entry and Exit Rules: Based on price position relative to key zones and moving average, along with optional stop-loss and take-profit levels.
Detailed Description
Swing High and Swing Low Analysis
The script calculates Swing High and Swing Low based on the most recent price highs and lows over a specified look-back period (swingHighLength and swingLowLength, set to 8 by default).
It then derives the Premium, Equilibrium, and Discount Zones:
Premium Zone: Represents potential resistance, calculated based on recent swing highs.
Discount Zone: Represents potential support, calculated based on recent swing lows.
Equilibrium: The midpoint between Swing High and Swing Low, dividing the price range into Premium (above equilibrium) and Discount (below equilibrium) areas.
Zone Visualization
The strategy plots the Premium Zone (resistance) in red, the Discount Zone (support) in green, and the Equilibrium level in blue on the chart. This helps visually assess the current price relative to these important areas.
Simple Moving Average (SMA)
A 50-period Simple Moving Average (SMA) is added to help identify the trend direction.
Buy signals are valid only if the price is above the SMA, indicating an uptrend.
Sell signals are valid only if the price is below the SMA, indicating a downtrend.
Entry Rules
The script generates buy or sell signals when certain conditions are met:
A buy signal is triggered when:
Price is below the Equilibrium and within the Discount Zone.
Price is above the SMA.
The buy signal is further confirmed by the presence of an Order Block (recent lowest price area).
A sell signal is triggered when:
Price is above the Equilibrium and within the Premium Zone.
Price is below the SMA.
The sell signal is further confirmed by the presence of an Order Block (recent highest price area).
Order Block
The strategy defines Order Blocks as recent highs and lows within a look-back period (orderBlockLength set to 20 by default).
These blocks represent areas where large players (smart money) have historically been active, increasing the probability of the price reacting in these areas again.
Trade Management and Trade Direction
The user can set Trade Direction to either "Long Only," "Short Only," or "Both." This allows the strategy to adapt based on market conditions or trading preferences.
Based on the Trade Direction, the strategy either:
Closes open trades that are against new signals.
Allows only specific directional trades (either long or short).
Stop-loss levels are defined based on a fixed percentage (stop_loss_percent), which helps to manage risk and minimize losses.
Exit Rules
The strategy uses stop-loss levels for risk management.
A stop-loss price is set at a fixed percentage below the entry price for long positions or above the entry price for short positions.
When the price hits the defined stop-loss level, the trade is closed.
Liquidity Zones
The script identifies recent Swing Highs and Lows as potential liquidity zones. These are levels where price could react strongly, as they represent areas of interest for large traders.
The liquidity zones are plotted as crosses on the chart, marking areas where price may encounter significant buying or selling pressure.
Visual Feedback
The script uses visual markers (green for buy signals and red for sell signals) to indicate potential entries on the chart.
It also plots liquidity zones to help traders identify areas where stop hunts and liquidity grabs might occur.
Monthly Performance Dashboard
The script includes a performance tracking feature that displays monthly profit and loss metrics on the chart.
This dashboard allows the trader to see a visual representation of trading performance over time, providing insights into profitability and consistency.
The table shows profit or loss for each month and year, allowing the user to track the overall success of the strategy.
Key Benefits
Smart Money Concepts (SMC): This strategy incorporates SMC principles like order blocks and liquidity zones, which are used by institutional traders to determine potential market moves.
Zone Analysis: The use of Premium, Discount, and Equilibrium zones provides a solid framework for determining where to enter and exit trades based on price discounts or premiums.
Confluence: Signals are not taken in isolation. They are confirmed by factors like trend direction (SMA) and order blocks, providing greater trade accuracy.
Risk Management: By integrating stop-loss functionality, traders can manage their risks effectively.
Visual Performance Metrics: The monthly and yearly performance dashboard gives valuable feedback on how well the strategy has performed historically.
Practical Use
Buy in Discount Zone: Traders would be looking to buy when the price is discounted relative to its recent range and is above the SMA, indicating an overall uptrend.
Sell in Premium Zone: Conversely, traders would be looking to sell when the price is at a premium relative to its recent range and below the SMA, indicating an overall downtrend.
Order Block Confirmation: Ensures that buying or selling is supported by historical price behavior at significant levels, providing confidence that the market is likely to react at these areas.
This strategy is designed to help traders take advantage of price inefficiencies and areas where institutional traders are likely to be active, increasing the odds of successful trades. By leveraging Smart Money concepts and strong technical confluence, it aims to provide high-probability trade setups.
Enhanced London Session SMC SetupEnhanced London Session SMC Setup Indicator
This Pine Script-based indicator is designed for traders focusing on the London trading session, leveraging smart money concepts (SMC) to identify potential trading opportunities in the GBP/USD currency pair. The script uses multiple techniques such as Order Block Detection, Imbalance (Fair Value Gap) Analysis, Change of Character (CHoCH) detection, and Fibonacci retracement levels to aid in market structure analysis, providing a well-rounded approach to trade setups.
Features:
London Session Highlight:
The indicator visually marks the London trading session (from 08:00 AM to 04:00 PM UTC) on the chart using a blue background, signaling when the high-volume, high-impulse moves tend to occur, helping traders focus their analysis on this key session.
Order Block Detection:
Identifies significant impulse moves that may form order blocks (supply and demand zones). Order blocks are areas where institutions have executed large orders, often leading to price reversals or continuation. The indicator plots the high and low of these order blocks, providing key levels to monitor for potential entries.
Imbalance (Fair Value Gap) Detection:
Detects and highlights price imbalances or fair value gaps (FVG) where the market has moved too quickly, creating a gap in price action. These areas are often revisited by price, offering potential trade opportunities. The upper and lower bounds of the imbalance are visually marked for easy reference.
Change of Character (CHoCH) Detection:
This feature identifies potential trend reversals by detecting significant changes in market character. When the price action shifts from bullish to bearish or vice versa, a CHoCH signal is triggered, and the corresponding level is marked on the chart. This can help traders catch trend reversals at key levels.
Fibonacci Retracement Levels:
The script calculates and plots the key Fibonacci retracement levels (0.618 and 0.786 by default) based on the highest and lowest points over a user-defined swing lookback period. These levels are commonly used by traders to identify potential pullback zones where price may reverse or find support/resistance.
Directional Bias Based on Market Structure:
The indicator provides a market structure analysis by comparing the current highs and lows to the previous periods' highs and lows. This helps in identifying whether the market is in a bullish or bearish state, providing a clear directional bias for trade setups.
Alerts:
The indicator comes with built-in alert conditions to notify the trader when an order block, imbalance, CHoCH, or other significant price action event is detected, ensuring timely action can be taken.
Ideal Usage:
Timeframe: Suitable for intraday trading, particularly focusing on the London session (08:00 AM to 04:00 PM UTC).
Currency Pair: Specifically designed for GBP/USD but can be adapted to other pairs with similar market behavior.
Trading Strategy: Best used in conjunction with a price action strategy, focusing on the key levels identified (order blocks, FVG, CHoCH) and using Fibonacci retracement levels for precision entries.
Target Audience: Ideal for traders who follow smart money concepts (SMC) and are looking for a structured approach to identify high-probability setups during the London session.
Smart Money Concepts IndicatorBEST ICT AND SMC INDICATOR
The **Smart Money Concepts Indicator** is designed to enhance trading decisions by incorporating key principles from Smart Money Concepts (SMC), focusing on the detection of market structure changes, liquidity zones, order flow, and order blocks. This indicator is particularly useful for traders looking to understand market dynamics and make informed trading decisions based on advanced market analysis.
#### Key Features:
1. **Break of Structure (BOS)**:
- Identifies upward and downward breaks in market structure, indicating potential trend reversals.
- Visual markers on the chart help traders spot these critical levels.
2. **Change of Character (CHOCH)**:
- Detects significant changes in market direction, highlighting potential shifts in momentum.
- Clearly labeled signals indicate when the market may be changing its character.
3. **Order Blocks**:
- Highlights order blocks, which are key areas where significant buying or selling has occurred.
- Provides visual cues for potential support and resistance zones.
4. **Liquidity Zones**:
- Marks liquidity zones, indicating areas where buy-side or sell-side liquidity may be targeted.
- Helps traders understand where the market might draw liquidity.
5. **Dynamic Take Profit and Stop Loss Levels**:
- Calculates and plots take profit (TP) and stop loss (SL) levels based on the Average True Range (ATR) for adaptive risk management.
- Customizable multipliers allow traders to adjust levels based on their risk tolerance.
6. **Order Flow Analysis**:
- Displays bullish and bearish order flow signals based on candle close relative to open.
- Provides insights into market sentiment and potential future price action.
#### How to Use:
- **Identifying Entry and Exit Points**: Use BOS and CHOCH signals to find potential entry points, while leveraging TP and SL levels for risk management.
- **Market Analysis**: Analyze order blocks and liquidity zones to make informed decisions on market behavior.
- **Visual Confirmation**: The clear visual cues provided by the indicator make it easier to interpret market movements and align trades with institutional behavior.
#### Conclusion:
The Smart Money Concepts Indicator is an invaluable tool for traders looking to enhance their understanding of market structure and make more informed trading decisions. By integrating advanced concepts like BOS, CHOCH, and liquidity analysis, this indicator helps traders navigate the complexities of the market with greater confidence.
Price Action Toolkit Lite [UAlgo]The Price Action Toolkit Lite is a comprehensive indicator designed to enhance your chart analysis with advanced price action tools. This powerful toolkit combines multiple technical analysis concepts to provide traders with a clear visualization of market structure, liquidity levels, order blocks, and trend lines. By integrating these elements, the indicator aims to offer a holistic view of price action, helping traders identify potential entry and exit points, as well as key levels of interest in the market.
🔶 Key Features
Market Structure Analysis: The indicator includes a ZigZag feature to highlight significant market highs and lows, aiding in the visualization of market structure changes and trends.
Liquidity Sweeps Detection: It identifies and displays liquidity sweeps, which are crucial for recognizing potential market reversals and areas of interest where significant price action is likely to occur.
Order Blocks: Automatically detects and draws order blocks, highlighting areas of institutional buying and selling pressure, which can serve as key support and resistance levels.
Trend Lines: The toolkit can draw and extend trend lines based on pivot points, providing a clear view of prevailing market trends and potential breakout points.
Customizable Settings: Users can adjust various settings, including the length of the ZigZag, liquidity detection sensitivity, the number of order blocks to display, and trend line detection parameters, allowing for a tailored analysis experience.
🔶 Disclaimer
The "Price Action Toolkit Lite " is intended for educational and informational purposes only.
It is not financial advice and should not be construed as such. Trading in financial markets involves substantial risk, including the risk of loss.
Past performance is not indicative of future results.
🔷 Similar Scripts
NormInvTargetSeekerNormInvTargetSeeker
The NormInvTargetSeeker is a trading tool designed to aid traders in identifying and capitalizing on Distribution and Accumulation zones, highlighting specific price levels that could serve as targets for future price movements. Although the indicator itself is not multi-timeframe, an effective trading strategy might involve signal validation across multiple timeframes.
🔶 USAGE
The indicator identifies Distribution and Accumulation zones, providing potential targets for future price moves.
Traders are encouraged to use these zones as profit targets or potential reversal points.
Confluence Zones
These zones are identified as regions where various factors or levels converge, signaling an increased probability of price reaction.
They can be used to reinforce signals or identify levels where price might encounter significant resistance or support.
🔹 Trading Strategy
First, identify a signal on your primary trading timeframe.
Manually check higher timeframes to ensure the signal aligns with them.
Use the identified zones, whether Distribution or Accumulation, as target zones for your trades.
🔶 Order Blocks
The NormInvTargetSeeker identifies "Order Blocks" by examining a specified number of consecutive candles with a specific condition: the current candle must completely engulf the previous candle. This means that both the high and low of the current candle are higher and lower, respectively, than the high and low of the previous candle, signifying a dominant move in the direction of the current candle.
🔹 Trading Strategy
Target Confirmation: Order Blocks can serve to confirm target points, providing additional validation for identified levels.
Market Insight: They offer crucial insights into whether "big hands" or institutional players are positioned as buyers or sellers in the market.
Traders can use Order Blocks as a means to validate targets or key price levels, observing if the price reacts significantly upon reaching these blocks.
They can also provide insights into the general market direction or underlying market strength by identifying where the major market players are placing their orders.
🔶 SETTINGS
The indicator allows users to adjust various parameters to customize the display and logic of the tool to fit their needs.
🔹 Display Settings
Users can customize the colors and displays of various zones and labels to match their preferences.
🔶 LICENSE AND CREDITS
This work is licensed under Attribution-NonCommercial-ShareAlike 4.0 International (CC BY-NC-SA 4.0). More information here: creativecommons.org
This indicator utilizes a TypeScript implementation of the Normal Inverse function as a reference, which can be found here : github.com
Special thanks to the authors of the referenced code for providing a foundation upon which this indicator was built.
🔶 UPDATES
Current Version: 1.0.0
For future updates, please check the comment section.
🔶 CONTACT
For any questions or suggestions, please feel free to contact @RickSimpson on TradingView.
ICT SMC Custom — BOS/MSS + OB + FVGWant me to fill that box? Here’s a ready‑to‑paste description for your publish screen:
⸻
ICT SMC Custom — BOS/MSS + OB + FVG (Crypto‑friendly)
A clean Smart Money Concepts tool that marks Break of Structure (BOS), Market Structure Shift (MSS), Order Blocks (OB), and Fair Value Gaps (FVG) with bold, easy‑to‑see visuals. Built for crypto but works on any market and timeframe.
What it does
• BOS & MSS detection with optional body/wick logic
• Order Blocks: auto‑draws the last opposite candle before a BOS, keeps only the most recent N, and fades when mitigated
• FVGs: 3‑candle gaps with a minimum size filter and a cap on how many to keep
• HTF Swings (optional): plots higher‑timeframe pivot highs/lows for top‑down context
• Alerts for BOS/MSS and FVG formation
Inputs
• Swing pivot length (default 3): sensitivity for structure pivots
• Use candle bodies for breaks: close vs level (on) or wicks (off)
• Show BOS/MSS labels, Show FVG, Show Order Blocks
• Min FVG size (ticks) and Max boxes to keep for FVG/OB
• OB uses candle body: body range vs full wick range
• Show higher timeframe swings + HTF timeframe
• Bullish/Bearish colors
How it works
• BOS triggers when price breaks the last opposite swing.
• MSS flags when the break flips the prior bias.
• OB is the most recent opposite candle prior to BOS; it’s marked and later greyed out once price closes through it (mitigation).
• FVG is detected when candle 1’s high < candle 3’s low (bear) or candle 1’s low > candle 3’s high (bull).
Alerts included
• BOS Up / BOS Down
• MSS Up / MSS Down
• FVG Up / FVG Down
Tips
• Start on 15m/1h for crypto, pivot length 3–5.
• Turn Use candle bodies ON for stricter confirmations, OFF for more signals.
• If boxes look cluttered, lower “Max boxes to keep.”
Note: This is a visual/educational tool, not financial advice. Always confirm with your own plan and risk management.
Orderblocks | iSolani
Revealing Institutional Footprints: The iSolani Volume-Powered Order Block System
Where Smart Money Leaves Its Mark – Automated Zone Detection for Discretionary Traders
Core Methodology
Pressure-Weighted Volume Analysis
Calculates directional commitment using candle position:
Buying Pressure = Total Volume × (Closing Price – Low) / (High – Low)
Selling Pressure = Total Volume × (High – Closing Price) / (High – Low)
Normalizes values against 31-period EMAs to filter retail noise
Adaptive Block Triggering
Identifies significant zones when:
Absolute Buy/Sell Difference > 4× SMA of Historical Differences (default)
Price closes bullishly (green block) or bearishly (red block)
Self-Maintaining Visualization
Blocks auto-extend rightward until price breaches critical level
Invalidated zones removed in real-time via array management
Technical Innovation
Dynamic Threshold Adjustment
Multiplier parameter (default 4) automatically scales with market volatility
Institutional-Grade Metrics
Blocks display:
Volume disparity in absolute terms
Percentage deviation from 33-period average
Directional bias through color-coding
Efficient Memory Handling
O(n) complexity cleanup routine prevents chart lag
System Workflow
Calculates real-time buy/sell pressure ratios
Compares to historical average (31-period default)
Generates semi-transparent zones (85% opacity) at spike locations
Monitors price interaction with block boundaries
Automatically retracts invalid zones
Standard Configuration
Sensitivity : 4× multiplier (ideal for 15m-4h charts)
Visuals : Red/green blocks with white text labels
Duration : 50-bar default extension
Volume Baseline : 33-period EMA filter
Boundary Check : Close beyond block high/low triggers deletion
This system transforms raw market data into a institutional roadmap – not by predicting turns, but by revealing where concentrated volume makes turns statistically probable. The color-coded blocks serve as persistent yet adaptive markers of where professional liquidity resides.
ICT Candle Block (fadi)ICT Candle Block
When trading using ICT concepts, it is often beneficial to treat consecutive candles of the same color as a single entity. This approach helps traders identify Order Blocks, liquidity voids, and other key trading signals more effectively.
However, in situations where the market becomes choppy or moves slowly, recognizing continuous price movement can be challenging.
The ICT Candle Block indicator addresses these challenges by combining consecutive candles of the same color into a single entity. It redraws the resulting candles, making price visualization much easier and helping traders quickly identify key trading signals.
FVGs and Blocks
In the above snapshot, FVGs/Liquidity Voids, Order Blocks, and Breaker Blocks are easily identified. By analyzing the combined candles, traders can quickly determine the draw on liquidity and potential price targets using ICT concepts.
Unlike traditional higher timeframes that rigidly combine lower timeframe candles based on specific start and stop times, this indicator operates as a "mixed timeframe." It combines all buying and all selling activities into a single candle, regardless of when the transactions started and ended.
Limitations
There are currently TradingView limitations that affect the functionality of this indicator:
TradingView does not have a Candle object; therefore, this indicator relies on using boxes and lines to mimic the candles. This results in wider candles than expected, leading to misalignment with the time axis below (plotcandle is not the answer).
There is a limit on the number of objects that can be drawn on a chart. A maximum of 500 candles has been set.
A rendering issue may cause a sideways box to appear across the chart. This is a display bug in TradingView; scroll to the left until it clears.
ICT Setup 03 [TradingFinder] Judas Swing NY 9:30am + CHoCH/FVG🔵 Introduction
Judas Swing is an advanced trading setup designed to identify false price movements early in the trading day. This advanced trading strategy operates on the principle that major market players, or "smart money," drive price in a certain direction during the early hours to mislead smaller traders.
This deceptive movement attracts liquidity at specific levels, allowing larger players to execute primary trades in the opposite direction, ultimately causing the price to return to its true path.
The Judas Swing setup functions within two primary time frames, tailored separately for Forex and Stock markets. In the Forex market, the setup uses the 8:15 to 8:30 AM window to identify the high and low points, followed by the 8:30 to 8:45 AM frame to execute the Judas move and identify the CISD Level break, where Order Block and Fair Value Gap (FVG) zones are subsequently detected.
In the Stock market, these time frames shift to 9:15 to 9:30 AM for identifying highs and lows and 9:30 to 9:45 AM for executing the Judas move and CISD Level break.
Concepts such as Order Block and Fair Value Gap (FVG) are crucial in this setup. An Order Block represents a chart region with a high volume of buy or sell orders placed by major financial institutions, marking significant levels where price reacts.
Fair Value Gap (FVG) refers to areas where price has moved rapidly without balance between supply and demand, highlighting zones of potential price action and future liquidity.
Bullish Setup :
Bearish Setup :
🔵 How to Use
The Judas Swing setup enables traders to pinpoint entry and exit points by utilizing Order Block and FVG concepts, helping them align with liquidity-driven moves orchestrated by smart money. This setup applies two distinct time frames for Forex and Stocks to capture early deceptive movements, offering traders optimized entry or exit moments.
🟣 Bullish Setup
In the Bullish Judas Swing setup, the first step is to identify High and Low points within the initial time frame. These levels serve as key points where price may react, forming the basis for analyzing the setup and assisting traders in anticipating future market shifts.
In the second time frame, a critical stage of the bullish setup begins. During this phase, the price may create a false break or Fake Break below the low level, a deceptive move by major players to absorb liquidity. This false move often causes smaller traders to enter positions incorrectly. After this fake-out, the price reverses upward, breaking the CISD Level, a critical point in the market structure, signaling a potential bullish trend.
Upon breaking the CISD Level and reversing upward, the indicator identifies both the Order Block and Fair Value Gap (FVG). The Order Block is an area where major players typically place large buy orders, signaling potential price support. Meanwhile, the FVG marks a region of supply-demand imbalance, signaling areas where price might react.
Ultimately, after these key zones are identified, a trader may open a buy position if the price reaches one of these critical areas—Order Block or FVG—and reacts positively. Trading at these levels enhances the chance of success due to liquidity absorption and support from smart money, marking an opportune time for entering a long position.
🟣 Bearish Setup
In the Bearish Judas Swing setup, analysis begins with marking the High and Low levels in the initial time frame. These levels serve as key zones where price could react, helping to signal possible trend reversals. Identifying these levels is essential for locating significant bearish zones and positioning traders to capitalize on downward movements.
In the second time frame, the primary bearish setup unfolds. During this stage, price may exhibit a Fake Break above the high, causing a brief move upward and misleading smaller traders into incorrect positions. After this false move, the price typically returns downward, breaking the CISD Level—a crucial bearish trend indicator.
With the CISD Level broken and a bearish trend confirmed, the indicator identifies the Order Block and Fair Value Gap (FVG). The Bearish Order Block is a region where smart money places significant sell orders, prompting a negative price reaction. The FVG denotes an area of supply-demand imbalance, signifying potential selling pressure.
When the price reaches one of these critical areas—the Bearish Order Block or FVG—and reacts downward, a trader may initiate a sell position. Entering trades at these levels, due to increased selling pressure and liquidity absorption, offers traders an advantage in profiting from price declines.
🔵 Settings
Market : The indicator allows users to choose between Forex and Stocks, automatically adjusting the time frames for the "Opening Range" and "Trading Permit" accordingly: Forex: 8:15–8:30 AM for identifying High and Low points, and 8:30–8:45 AM for capturing the Judas move and CISD Level break. Stocks: 9:15–9:30 AM for identifying High and Low points, and 9:30–9:45 AM for executing the Judas move and CISD Level break.
Refine Order Block : Enables finer adjustments to Order Block levels for more accurate price responses.
Mitigation Level OB : Allows users to set specific reaction points within an Order Block, including: Proximal: Closest level to the current price. 50% OB: Midpoint of the Order Block. Distal: Farthest level from the current price.
FVG Filter : The Judas Swing indicator includes a filter for Fair Value Gap (FVG), allowing different filtering based on FVG width: FVG Filter Type: Can be set to "Very Aggressive," "Aggressive," "Defensive," or "Very Defensive." Higher defensiveness narrows the FVG width, focusing on narrower gaps.
Mitigation Level FVG : Like the Order Block, you can set price reaction levels for FVG with options such as Proximal, 50% OB, and Distal.
CISD : The Bar Back Check option enables traders to specify the number of past candles checked for identifying the CISD Level, enhancing CISD Level accuracy on the chart.
🔵 Conclusion
The Judas Swing indicator helps traders spot reliable trading opportunities by detecting false price movements and key levels such as Order Block and FVG. With a focus on early market movements, this tool allows traders to align with major market participants, selecting entry and exit points with greater precision, thereby reducing trading risks.
Its extensive customization options enable adjustments for various market types and trading conditions, giving traders the flexibility to optimize their strategies. Based on ICT techniques and liquidity analysis, this indicator can be highly effective for those seeking precision in their entry points.
Overall, Judas Swing empowers traders to capitalize on significant market movements by leveraging price volatility. Offering precise and dependable signals, this tool presents an excellent opportunity for enhancing trading accuracy and improving performance
Cnagda Liquidit Trading SystemCnagda Liquidit Trading System helps spot where price is likely to trap traders and reverse, then gives simple, actionable Level to entry, place SL, and take profits with confidence. It blends imbalance zones, trend bias, order blocks, liquidity pools, high-probability fake Signal, and context-aware candle patterns into one clean workflow.
🟩🟥 Imbalance boxes: “Crowd rushed, gaps left”
What it is: Green/red boxes mark fast, one-sided moves where price “skipped” orders—think FVG-like zones that often get revisited.
Why it helps: Price frequently pulls back to “fill” these zones, creating clean retest entries with logical stops.
⏩How to use:
Green box = potential demand retest; Red box = potential supply retest. Enter on pullback into box, not on first impulse. Put stop on far side of box and aim first targets at recent swing points.
↕️ Swing bias (HH/HL vs LH/LL): “Which way is the road?”
What it is: Higher-highs/higher-lows = up-bias; Lower-highs/lower-lows = down-bias. system plots Buy/Sell OB levels aligned with that bias.
Why it helps: Trading with the broader flow reduces “hero trades” against institutions. Bias gives clearer entries and cleaner drawdowns.
⏩How to use:
Up-bias: look for long on Buy OB retests. Down-bias: look for short on Sell OB retests. Wait for a small rejection/engulfing to confirm before triggering.
🧱Order blocks: “Where big players remember”
What it is: last opposite-colored candle before an impulsive move—these zones often hold memory and reaction. system plots these as Buy/Sell OB lines.
Why it helps: Many breakouts pull back to the origin. Good entries often happen on retest, not on the breakout chase.
⏩ How to use:
Let price return into the OB, show wick rejection, and decent volume. Enter with stop beyond OB; define risk-reward before entry.
📊Volume coloring: “How Volume is move?”
What it is: Bar color reflects relative volume; inside bars are black. The dashboard also shows Volume and “Volume vs Prev.”
Why it helps: Patterns without volume often fade; volume validates strength and intent of moves.
⏩ How to use:
Favor entries where imbalance/OB/liquidity-grab coincide with higher volume. If volume is weak, reduce size or skip.
🧲 BSL/SSL liquidity pools: “Fishing for stops”
What it is: Equal highs cluster stops above (BSL); equal lows cluster stops below (SSL). system plots these and highlights the nearest one (“magnet”).
Why it helps: Price often sweeps these pools to trigger stops before reversing. This is a prime trap-reversal location.
⏩ How to use:
Watch nearest BSL/SSL. If price wicks through and closes back inside, anticipate a reversal. Trade reaction, not first poke. When price closes beyond, consider that pool mitigated and move on.
🟢🔴 Advanced liquidity grab: “Catch fakeout”
What it is: Bullish grab = makes a new low beyond a prior low but closes back above it, with a long lower wick, small body, and higher volume. Bearish is mirror. Labeled automatically.
Why it helps: It exposes trap moves (stop hunts) and often precedes true direction.
⏩ How to use:
Best when it aligns with a nearby imbalance/OB and supportive volume. Enter on reversal candle break or on retest. Stop goes beyond sweep wick.
🧠 Smart candlestick patterns (only in right place)
What it is: Engulfing, Hammer, Shooting Star, Hanging Man, Doji (with high volume), Morning/Evening Star, Piercing—but marked “effective” only if context (swing/trend/location) agrees.
Why it helps: same pattern in the wrong place is noise; in the right place, it’s signal.
⏩ How to use:
Location first (BSL/SSL/OB/imbalance), then pattern. Treat pattern as trigger/confirmation—one fresh label shows to keep chart clean.
🧭 Dashboard: “Context in a glance”
⏩ Reversal Level: current swing anchor—expect turns or reactions nearby; great for alerts and planning.
⏩ Volume vs Prev + Volume: Strength meter for signal candle—higher adds conviction.
⏩ Nearest Pool: next “magnet” area—look for sweeps/rejections there.
🧩Step-by-step trading flow (with mindset)
⏩ Set bias: HH/HL = long bias, LH/LL = short bias. Counter-trend only on clean sweeps with strong confirmation.
⏩ Find magnet: Check Nearest Pool (BSL/SSL). Focus attention there; it saves screen time.
⏩ Wait for event: Look for a sweep/grab label, or sharp rejection at pool/OB/imbalance. Avoid FOMO.
⏩ Add confluence: Stack 2–3 of these—imbalance box, OB, contextual pattern, supportive volume.
⏩Plan entry: Bullish: trigger above reversal candle high or take retest of FVG/OB. Stop below sweep wick/zone. Target at least 1:1.5–1:2.
Bearish: mirror above.
⏩Manage smartly: Take partials, move to breakeven or trail thoughtfully. Don’t drag stops inside zone out of emotion.
🎛️ Parameter tuning (to reduce human error)
⏩ swingLen: Smaller = faster but noisier; larger = cleaner but slower. Backtest first, then go live.
⏩ Tolerance (ATR or percent): ATR tolerance adapts to volatility (good for fast markets and lower TFs). Start around 0.15–0.30. In calm markets, try percent 0.05–0.15%.
⏩ minBarsGap: Start with 3–5 so equal highs/lows are truly equal—reduces false pools.
❌Common mistakes → ✅ Better habits
⏩Chasing every breakout → Wait for sweep/rejection, then confirm.
⏩Ignoring volume → Validate strength; cut size or skip on weak volume.
⏩Losing history of pools → If reviewing/backtesting, keep mitigated pools visible (dashed/faded).
⏩Over-tight tolerance/too small swingLen → Increases false signals; backtest to find balance.
📝 checklist (before entry)
⏩ Is there a nearby BSL/SSL and did a sweep/grab happen there?
⏩ Is there a close imbalance/OB that price can retest?
⏩ Do we have an effective pattern plus supportive volume?
⏩Is the stop beyond the wick/zone and RR ≥ 1:1.5?
•?((¯°·._.• 🎀 𝐻𝒶𝓅𝓅𝓎 𝒯𝓇𝒶𝒹𝒾𝓃𝑔 🎀 •._.·°¯((?•
TRI - Smart Zones============================================================================
# TRI - SMART ZONES v2.0
## Professional Smart Money Concepts Indicator for Pine Script v6
============================================================================
## 📊 OVERVIEW
**TRI - Smart Zones** is a comprehensive Smart Money Concepts indicator that
combines multiple institutional trading concepts into a single, powerful tool.
Built with Pine Script v6 for optimal performance and reliability.
## 🎯 CORE FEATURES
### **Fair Value Gaps (FVG)**
- **Detection**: Automatic identification of price imbalances
- **Types**: Bullish and Bearish Fair Value Gaps
- **Threshold**: Customizable gap size requirements (0.1% default)
- **Extension**: Configurable zone projection length
- **Mitigation**: Real-time tracking of gap fills
### **Order Blocks (OB)**
- **Detection**: Volume-based institutional footprint identification
- **Types**: Bullish and Bearish Order Blocks
- **Method**: Pivot-based volume analysis with configurable lookback
- **Validation**: Market structure confirmation required
- **Extension**: Adjustable zone projection
### **BSL/SSL Liquidity Levels**
- **Multi-Timeframe**: Automatic higher timeframe reference
- **Dynamic**: Real-time level updates and extensions
- **Visual**: Clear line markings with timeframe labels
- **Smart**: Adaptive timeframe selection based on current chart
### **Fibonacci Extensions**
- **ZigZag Integration**: Advanced pivot point detection
- **Levels**: Customizable Fibonacci ratios (38.2%, 61.8%, 100%, 161.8%)
- **Projection**: Dynamic extension from swing points
- **Visual**: Subtle dashed lines with level/price labels
### **Smart Dashboard**
- **Zone Statistics**: Real-time FVG and OB counts
- **Success Rates**: Mitigation percentages for each zone type
- **Market Bias**: Intelligent bullish/bearish/neutral assessment
- **Positioning**: Customizable location and size
### **Zone Analysis Engine**
- **Technical Confluence**: RSI, ADX, ATR, Volume analysis
- **VWAP Integration**: Institutional price reference
- **Confidence Scoring**: High/Mid/Low signal classification
- **Signal Arrows**: Visual trade direction indicators
## 🔔 ALERT SYSTEM
### **Market Structure Alerts**
- `Market Bias Changed` - Shift in overall market sentiment
- `BSL Touched` - Buy Side Liquidity level reached
- `SSL Touched` - Sell Side Liquidity level reached
### **Zone Touch Alerts**
- `OB Touched` - Any Order Block interaction
- `Bullish OB Touched` - Bullish Order Block touch
- `Bearish OB Touched` - Bearish Order Block touch
- `FVG Touched` - Any Fair Value Gap interaction
- `Bullish FVG Touched` - Bullish FVG touch
- `Bearish FVG Touched` - Bearish FVG touch
- `Zone Touched` - Any Smart Zone interaction
- `Bullish Zone Touched` - Any bullish zone touch
- `Bearish Zone Touched` - Any bearish zone touch
## ⚙️ CONFIGURATION
### **Zone Detection**
- Enable/disable FVG and OB detection independently
- Maximum zones per type (3-15, default: 8)
- Zone-specific threshold and extension settings
### **Visual Customization**
- Individual color schemes for each zone type
- Adjustable transparency levels
- Configurable line styles and widths
- Dashboard positioning and sizing options
### **Technical Analysis**
- RSI, ADX, ATR period customization
- Volume threshold multipliers
- Confidence level color coding
- Signal display toggle
## 🚀 PINE SCRIPT v6 OPTIMIZATIONS
- **User-Defined Types**: Structured data for zones and statistics
- **Methods**: Type-specific operations for better code organization
- **Enhanced Arrays**: Optimized memory management
- **Switch Statements**: Improved performance for zone classification
- **Error Handling**: Robust input validation and edge case management
- **Performance**: Efficient algorithms for real-time analysis
## 📈 TRADING APPLICATIONS
### **Entry Strategies**
- Zone confluence for high-probability setups
- Multi-timeframe confirmation via BSL/SSL
- Fibonacci extension targets
- Signal arrows for directional bias
### **Risk Management**
- Zone mitigation for stop-loss placement
- Market bias for position sizing
- Dashboard statistics for strategy validation
### **Market Analysis**
- Institutional footprint identification
- Liquidity level mapping
- Market structure assessment
- Trend continuation vs reversal analysis
## 🔧 TECHNICAL SPECIFICATIONS
- **Version**: Pine Script v6
- **Overlay**: True (draws on price chart)
- **Max Objects**: 100 boxes, 100 lines, 50 labels
- **Performance**: Optimized for real-time analysis
- **Compatibility**: All TradingView chart types and timeframes
Advanced ICT Theory - A-ICT📊 Advanced ICT Theory (A-ICT): The Institutional Manipulation Detector
Are you tired of being the liquidity? Stop chasing shadows and start tracking the architects of price movement.
This is not another lagging indicator. This is a complete framework for viewing the market through the lens of institutional traders. Advanced ICT Theory (A-ICT) is an all-in-one, military-grade analysis engine designed to decode the complex language of "Smart Money." It automates the core tenets of Inner Circle Trader (ICT) methodology, moving beyond simple patterns to build a dynamic, real-time narrative of market manipulation, liquidity engineering, and institutional order flow.
AIT provides a living blueprint of the market, identifying high-probability zones, tracking structural shifts, and scoring the quality of setups with a sophisticated, multi-factor algorithm. This is your X-ray into the market's true intentions.
🔬 THE CORE ENGINE: DECODING THE THEORY & FORMULAS
A-ICT is built upon a sophisticated, multi-layered logic system that interprets price action as a story of cause and effect. It does not guess; it confirms. Here is the foundational theory that drives the engine:
1. Market Structure: The Blueprint of Trend
The script first establishes a deep understanding of the market's skeleton through multi-level pivot analysis. It uses ta.pivothigh and ta.pivotlow to identify significant swing points.
Internal Structure (iBOS): Minor swings that show the short-term order flow. A break of internal structure is the first whisper of a potential shift.
External Structure (eBOS): Major swing points that define the primary trend. A confirmed break of external structure is a powerful statement of trend continuation. AIT validates this with optional Volume Confirmation (volume > volumeSMA * 1.2) and Candle Confirmation to ensure the break is driven by institutional force, not just a random spike.
Change of Character (CHoCH): This is the earthquake. A CHoCH occurs when a confirmed eBOS happens against the prevailing trend (e.g., a bearish eBOS in a clear uptrend). A-ICT flags this immediately, as it is the strongest signal that the primary trend is under threat of reversal.
2. Liquidity Engineering: The Fuel of the Market
Institutions don't buy into strength; they buy into weakness. They need liquidity. A-ICT maps these liquidity pools with forensic precision:
Buyside & Sellside Liquidity (BSL/SSL): Using ta.highest and ta.lowest, AIT identifies recent highs and lows where clusters of stop-loss orders (liquidity) are resting. These are institutional targets.
Liquidity Sweeps: This is the "manipulation" part of the detector. AIT has a specific formula to detect a sweep: high > bsl and close < bsl . This signifies that institutions pushed price just high enough to trigger buy-stops before aggressively selling—a classic "stop hunt." This event dramatically increases the quality score of subsequent patterns.
3. The Element Lifecycle: From Potential to Power
This is the revolutionary heart of A-ICT. Zones are not static; they have a lifecycle. AIT tracks this with its dynamic classification engine.
Phase 1: PENDING (Yellow): The script identifies a potential zone of interest based on a specific candle formation (a "displacement"). It is marked as "Pending" because its true nature is unknown. It is a question.
Phase 2: CLASSIFICATION: After the zone is created, AIT watches what happens next. The zone's identity is defined by its actions:
ORDER BLOCK (Blue): The highest-grade element. A zone is classified as an Order Block if it directly causes a Break of Structure (BOS) . This is the footprint of institutions entering the market with enough force to validate the new trend direction.
TRAP ZONE (Orange): A zone is classified as a Trap Zone if it is directly involved in a Liquidity Sweep . This indicates the zone was used to engineer liquidity, setting a "trap" for retail traders before a reversal.
REVERSAL / S&R ZONE (Green): If a zone is not powerful enough to cause a BOS or a major sweep, but still serves as a pivot point, it's classified as a general support/resistance or reversal zone.
4. Market Inefficiencies: Gaps in the Matrix
Fair Value Gaps (FVG): AIT detects FVGs—a 3-bar pattern indicating an imbalance—with a strict formula: low > high (for a bullish FVG) and gapSize > atr14 * 0.5. This ensures only significant, volatile gaps are shown. An FVG co-located with an Order Block is a high-confluence setup.
5. Premium & Discount: The Law of Value
Institutions buy at wholesale (Discount) and sell at retail (Premium). AIT uses a pdLookback to define the current dealing range and divides it into three zones: Premium (sell zone), Discount (buy zone), and Equilibrium. An element's quality score is massively boosted if it aligns with this principle (e.g., a bullish Order Block in a Discount zone).
⚙️ THE CONTROL PANEL: A COMPLETE GUIDE TO THE INPUTS MENU
Every setting is a lever, allowing you to tune the AIT engine to your exact specifications. Master these to unlock the script's full potential.
🎯 A-ICT Detection Engine
Min Displacement Candles: Controls the sensitivity of element detection. How it works: It defines the number of subsequent candles that must be "inside" a large parent candle. Best practice: Use 2-3 for a balanced view on most timeframes. A higher number (4-5) will find only major, more significant zones, ideal for swing trading. A lower number (1) is highly sensitive, suitable for scalping.
Mitigation Method: Defines when a zone is considered "used up" or mitigated. How it works: Cross triggers as soon as price touches the zone's boundary. Close requires a candle to fully close beyond it. Best practice: Cross is more responsive for fast-moving markets. Close is more conservative and helps filter out fake-outs caused by wicks, making it safer for confirmations.
Min Element Size (ATR): A crucial noise filter. How it works: It requires a detected zone to be at least this multiple of the Average True Range (ATR). Best practice: Keep this around 0.5. If you see too many tiny, irrelevant zones, increase this value to 0.8 or 1.0. If you feel the script is missing smaller but valid zones, decrease it to 0.3.
Age Threshold & Pending Timeout: These manage visual clutter. How they work: Age Threshold removes old, mitigated elements after a set number of bars. Pending Timeout removes a "Pending" element if it isn't classified within a certain window. Best practice: The default settings are optimized. If your chart feels cluttered, reduce the Age Threshold. If pending zones disappear too quickly, increase the Pending Timeout.
Min Quality Threshold: Your primary visual filter. How it works: It hides all elements (boxes, lines, labels) that do not meet this minimum quality score (0-100). Best practice: Start with the default 30. To see only A- or B-grade setups, increase this to 60 or 70 for an exceptionally clean, high-probability view.
🏗️ Market Structure
Lookbacks (Internal, External, Major): These define the sensitivity of the trend analysis. How they work: They set the number of bars to the left and right for pivot detection. Best practice: Use smaller values for Internal (e.g., 3) to see minor structure and larger values for External (e.g., 10-15) to map the main trend. For a macro, long-term view, increase the Major Swing Lookback.
Require Volume/Candle Confirmation: Toggles for quality control on BOS/CHoCH signals. Best practice: It is highly recommended to keep these enabled. Disabling them will result in more structure signals, but many will be false alarms. They are your filter against market noise.
... (Continue this detailed breakdown for every single input group: Display Configuration, Zones Style, Levels Appearance, Colors, Dashboards, MTF, Liquidity, Premium/Discount, Sessions, and IPDA).
📊 THE INTELLIGENCE DASHBOARDS: YOUR COMMAND CENTER
The dashboards synthesize all the complex analysis into a simple, actionable intelligence briefing.
Main Dashboard (Bottom Right)
ICT Metrics & Breakdown: This is your statistical overview. Total Elements shows how much structure the script is tracking. High Quality instantly tells you if there are any A/B grade setups nearby. Unmitigated vs. Mitigated shows the balance of fresh opportunities versus resolved price action. The breakdown by Order Blocks, Trap Zones, etc., gives you a quick read on the market's recent character.
Structure & Market Context: This is your core bias. Order Flow tells you the current script-determined trend. Last BOS shows you the most recent structural event. CHoCH Active is a critical warning. HTF Bias shows if you are aligned with the higher timeframe—the checkmark (✓) for alignment is one of the most important confluence factors.
Smart Money Flow: A volume-based sentiment gauge. Net Flow shows the raw buying vs. selling pressure, while the Bias provides an interpretation (e.g., "STRONG BULLISH FLOW").
Key Guide (Large Dashboard only): A built-in legend so you never have to guess. It defines every pattern, structure type, and special level visually.
📖 Narrative Dashboard (Bottom Left)
This is the "story" of the market, updated in real-time. It's designed to build your trading thesis.
Recent Elements Table: A live list of the most recent, high-quality setups. It displays the Type , its Narrative Role (e.g., "Bullish OB caused BOS"), its raw Quality percentage, and its final Trade Score grade. This is your at-a-glance opportunity scanner.
Market Narrative Section: This is the soul of A-ICT. It combines all data points into a human-readable story:
📍 Current Phase: Tells you if you are in a high-volatility Killzone or a consolidation phase like the Asian Range.
🎯 Bias & Alignment: Your primary direction, with a clear indicator of HTF alignment or conflict.
🔗 Events: A causal sequence of recent events, like "💧 Sell-side liquidity swept →
📊 Bullish BOS → 🎯 Active Order Block".
🎯 Next Expectation: The script's logical conclusion. It provides a specific, forward-looking hypothesis, such as "📉 Pullback expected to bullish OB at 1.2345 before continuation up."
🎨 READING THE BATTLEFIELD: A VISUAL INTERPRETATION GUIDE
Every color and line is a piece of information. Learn to read them together to see the full picture.
The Core Zones (Boxes):
Blue Box (Order Block): Highest probability zone for trend continuation. Look for entries here.
Orange Box (Trap Zone): A manipulation footprint. Expect a potential reversal after price interacts with this zone.
Green Box (Reversal/S&R): A standard pivot area. A good reference point but requires more confluence.
Purple Box (FVG): A market imbalance. Acts as a magnet for price. An FVG inside an Order Block is an A+ confluence.
The Structural Lines:
Green/Red Line (eBOS): Confirms the trend direction. A break above the green line is bullish; a break below the red line is bearish.
Thick Orange Line (CHoCH): WARNING. The previous trend is now in question. The market character has changed.
Blue/Red Lines (BSL/SSL): Liquidity targets. Expect price to gravitate towards these lines. A dotted line with a checkmark (✓) means the liquidity has been "swept" or "purged."
How to Synthesize: The magic is in the confluence. A perfect setup might look like this: Price sweeps below a red SSL line , enters a green Discount Zone during the NY Killzone , and forms a blue Order Block which then causes a green eBOS . This sequence, visible at a glance, is the story of a high-probability long setup.
🔧 THE ARCHITECT'S VISION: THE DEVELOPMENT JOURNEY
A-ICT was forged from the frustration of using lagging indicators in a market that is forward-looking. Traditional tools are reactive; they tell you what happened. The vision for A-ICT was to create a proactive engine that could anticipate institutional behavior by understanding their objectives: liquidity and efficiency. The development process was centered on creating a "lifecycle" for price patterns—the idea that a zone's true meaning is only revealed by its consequence. This led to the post-breakout classification system and the narrative-building engine. It's designed not just to show you patterns, but to tell you their story.
⚠️ RISK DISCLAIMER & BEST PRACTICES
Advanced ICT Theory (A-ICT) is a professional-grade analytical tool and does not provide financial advice or direct buy/sell signals. Its analysis is based on historical price action and probabilities. All forms of trading involve substantial risk. Past performance is not indicative of future results. Always use this tool as part of a comprehensive trading plan that includes your own analysis and a robust risk management strategy. Do not trade based on this indicator alone.
観の目つよく、見の目よわく
"Kan no me tsuyoku, ken no me yowaku"
— Miyamoto Musashi, The Book of Five Rings
English: "Perceive that which cannot be seen with the eye."
— Dskyz, Trade with insight. Trade with anticipation.
ICT & SMC Multi-Timeframe by [KhedrFX]Transform your trading experience with the ICT & SMC Multi-Timeframe by indicator. This innovative tool is designed for traders who want to harness the power of multi-timeframe analysis, enabling them to make informed trading decisions based on key market insights. By integrating concepts from the Inner Circle Trader (ICT) and Smart Money Concepts (SMC), this indicator provides a comprehensive view of market dynamics, helping you identify potential trading opportunities with precision.
Key Features
- Multi-Timeframe Analysis: Effortlessly switch between various timeframes (5 minutes, 15 minutes, 30 minutes, 1 hour, 4 hours, daily, and weekly) to capture the full spectrum of market movements.
- High and Low Levels: Automatically calculates and displays the highest and lowest price levels over the last 20 bars, highlighting critical support and resistance zones.
- Market Structure Visualization: Identifies the last swing high and swing low, allowing you to recognize current market trends and potential reversal points.
- Order Block Detection: Detects significant order blocks, pinpointing areas of strong buying or selling pressure that can indicate potential market reversals.
- Custom Alerts: Set alerts for when the price crosses above or below identified order block levels, enabling you to act swiftly on trading opportunities.
How to Use the Indicator
1. Add the Indicator to Your Chart
- Open TradingView.
- Click on the "Indicators" button at the top of the screen.
- Search for "ICT & SMC Multi-Timeframe by " in the search bar.
- Click on the indicator to add it to your chart.
2. Select Your Timeframe
- Use the dropdown menu to choose your preferred timeframe (5, 15, 30, 60, 240, D, W) for analysis.
3. Interpret the Signals
- High Level (Green Line): Represents the highest price level over the last 20 bars, acting as a potential resistance level.
- Low Level (Red Line): Represents the lowest price level over the last 20 bars, acting as a potential support level.
- Last Swing High (Blue Cross): Indicates the most recent significant high, useful for identifying potential reversal points.
- Last Swing Low (Orange Cross): Indicates the most recent significant low, providing insight into market structure.
- Order Block High (Purple Line): Marks the upper boundary of a detected order block, suggesting potential selling pressure.
- Order Block Low (Yellow Line): Marks the lower boundary of a detected order block, indicating potential buying pressure.
4. Set Alerts
- Utilize the alert conditions to receive notifications when the price crosses above or below the order block levels, allowing you to stay informed about potential trading opportunities.
5. Implement Risk Management
- Always use proper risk management techniques. Consider setting stop-loss orders based on the identified swing highs and lows or the order block levels to protect your capital.
Conclusion
The ICT & SMC Multi-Timeframe by indicator is an essential tool for traders looking to enhance their market analysis and decision-making process. By leveraging multi-timeframe insights, market structure visualization, and order block detection, you can navigate the complexities of the market with confidence. Start using this powerful indicator today and take your trading to the next level.
⚠️ Trade Responsibly
This tool helps you analyze the market, but it’s not a guarantee of profits. Always do your own research, manage risk, and trade with caution.
Quarterly Theory ICT 03 [TradingFinder] Precision Swing Points🔵 Introduction
Precision Swing Point (PSP) is a divergence pattern in the closing of candles between two correlated assets, which can indicate a potential trend reversal. This structure appears at market turning points and highlights discrepancies between the price behavior of two related assets.
PSP typically forms in key timeframes such as 5-minute, 15-minute, and 90-minute charts, and is often used in combination with Smart Money Concepts (SMT) to confirm trade entries.
PSP is categorized into Bearish PSP and Bullish PSP :
Bearish PSP : Occurs when an asset breaks its previous high, and its middle candle closes bullish, while the correlated asset closes bearish at the same level. This divergence signals weakness in the uptrend and a potential price reversal downward.
Bullish PSP : Occurs when an asset breaks its previous low, and its middle candle closes bearish, while the correlated asset closes bullish at the same level. This suggests weakness in the downtrend and a potential price increase.
🟣 Trading Strategies Using Precision Swing Point (PSP)
PSP can be integrated into various trading strategies to improve entry accuracy and filter out false signals. One common method is combining PSP with SMT (divergence between correlated assets), where traders identify divergence and enter a trade only after PSP confirms the move.
Additionally, PSP can act as a liquidity gap, meaning that price tends to react to the wick of the PSP candle, making it a favorable entry point with a tight stop-loss and high risk-to-reward ratio. Furthermore, PSP combined with Order Blocks and Fair Value Gaps in higher timeframes allows traders to identify stronger reversal zones.
In lower timeframes, such as 5-minute or 15-minute charts, PSP can serve as a confirmation for more precise entries in the direction of the higher timeframe trend. This is particularly useful in scalping and intraday trading, helping traders execute smarter entries while minimizing unnecessary stop-outs.
🔵 How to Use
PSP is a trading pattern based on divergence in candle closures between two correlated assets. This divergence signals a difference in trend strength and can be used to identify precise market turning points. PSP is divided into Bullish PSP and Bearish PSP, each applicable for long and short trades.
🟣 Bullish PSP
A Bullish PSP forms when, at a market turning point, the middle candle of one asset closes bearish while the correlated asset closes bullish. This discrepancy indicates weakness in the downtrend and a potential price reversal upward.
Traders can use this as a signal for long (buy) trades. The best approach is to wait for price to return to the wick of the PSP candle, as this area typically acts as a liquidity level.
f PSP forms within an Order Block or Fair Value Gap in a higher timeframe, its reliability increases, allowing for entries with tight stop-loss and optimal risk-to-reward ratios.
🟣 Bearish PSP
A Bearish PSP forms when, at a market turning point, the middle candle of one asset closes bullish while the correlated asset closes bearish. This indicates weakness in the uptrend and a potential price decline.
Traders use this pattern to enter short (sell) trades. The best entry occurs when price retests the wick of the PSP candle, as this level often acts as a resistance zone, pushing price lower.
If PSP aligns with a significant liquidity area or Order Block in a higher timeframe, traders can enter with greater confidence and place their stop-loss just above the PSP wick.
Overall, PSP is a highly effective tool for filtering false signals and improving trade entry precision. Combining PSP with SMT, Order Blocks, and Fair Value Gaps across multiple timeframes allows traders to execute higher-accuracy trades with lower risk.
🔵 Settings
Mode :
2 Symbol : Identifies PSP and PCP between two correlated assets.
3 Symbol : Compares three assets to detect more complex divergences and stronger confirmation signals.
Second Symbol : The second asset used in PSP and correlation calculations.
Third Symbol : Used in three-symbol mode for deeper PSP and PCP analysis.
Filter Precision X Point : Enables or disables filtering for more precise PSP and PCP detection. This filter only identifies PSP and PCP when the base asset's candle qualifies as a Pin Bar.
Trend Effect : By changing the Trend Effect status to "Off," all Pin bars, whether bullish or bearish, are displayed regardless of the current market trend. If the status remains "On," only Pin bars in the direction of the main market trend are shown.
Bullish Pin Bar Setting : Using the "Ratio Lower Shadow to Body" and "Ratio Lower Shadow to Higher Shadow" settings, you can customize your bullish Pin bar candles. Larger numbers impose stricter conditions for identifying bullish Pin bars.
Bearish Pin Bar Setting : Using the "Ratio Higher Shadow to Body" and "Ratio Higher Shadow to Lower Shadow" settings, you can customize your bearish Pin bar candles. Larger numbers impose stricter conditions for identifying bearish Pin bars.
🔵 Conclusion
Precision Swing Point (PSP) is a powerful analytical tool in Smart Money trading strategies, helping traders identify precise market turning points by detecting divergences in candle closures between correlated assets. PSP is classified into Bullish PSP and Bearish PSP, each playing a crucial role in detecting trend weaknesses and determining optimal entry points for long and short trades.
Using the PSP wick as a key liquidity level, integrating it with SMT, Order Blocks, and Fair Value Gaps, and analyzing higher timeframes are effective techniques to enhance trade entries. Ultimately, PSP serves as a complementary tool for improving entry accuracy and reducing unnecessary stop-outs, making it a valuable addition to Smart Money trading methodologies.
Smart Money Concepts (Advanced)Inspired and initially based on LuxAlgo's Smart Money Concepts Indicator I created a library lib_smc that started to convert every function and return objects. This allowed certain customizations like tracking the current fill level of FVGs or tracking the creation of Order Blocks, by monitoring consecutive bars against the current trend.
This indicator is provided as is, based on, but probably not always be up to date with my lib_smc that I am using for my projects.
WARNING: This indicator shows EXPERIMENTAL Order Blocks that are tracked LIVE. Unlike usual Order Blocks these are not just based on the last confirmed Swing Point (formed 50 bars before) but on consecutive candles opposing an unconfirmed trend. Blocks are confirmed by price movements relative to the unconfirmed block and unconfirmed swing points. This means that some Order Blocks will appear on pullbacks, as well as reversals.
Features
Swing Points (HH / LH / HL / LL), indicating support / resistance zones price might reject off of or want to push through
Market Structure (BOS / ChoCh), indicates confirmation for a continued / changing trend
live Order Blocks (OB), see warning above.
Fair Value Gaps (FVG), optional from higher timeframes
Equal Highs / Lows (EQH/EQL), indicates strong support / resistance zones, especially when the bars forming it have long wicks toward that zone
using my lib_no_delay all moving averages are working from bar 0, so it can be used on charts with limited bars
